mirror of
https://github.com/fluencelabs/wasmer
synced 2025-05-30 02:11:20 +00:00
5900 lines
354 KiB
Rust
5900 lines
354 KiB
Rust
// Rust test file autogenerated with cargo build (src/build_spectests.rs).
|
|
// Please do NOT modify it by hand, as it will be reseted on next build.
|
|
// Test based on spectests/float_misc.wast
|
|
#![allow(
|
|
warnings,
|
|
dead_code
|
|
)]
|
|
use crate::webassembly::{instantiate, compile, ImportObject, ResultObject, VmCtx, Export};
|
|
use super::_common::{
|
|
spectest_importobject,
|
|
NaNCheck,
|
|
};
|
|
use wabt::wat2wasm;
|
|
|
|
|
|
// Line 17
|
|
fn create_module_1() -> ResultObject {
|
|
let module_str = "(module
|
|
(type (;0;) (func (param f32 f32) (result f32)))
|
|
(type (;1;) (func (param f32) (result f32)))
|
|
(type (;2;) (func (param f64 f64) (result f64)))
|
|
(type (;3;) (func (param f64) (result f64)))
|
|
(func (;0;) (type 0) (param f32 f32) (result f32)
|
|
get_local 0
|
|
get_local 1
|
|
f32.add)
|
|
(func (;1;) (type 0) (param f32 f32) (result f32)
|
|
get_local 0
|
|
get_local 1
|
|
f32.sub)
|
|
(func (;2;) (type 0) (param f32 f32) (result f32)
|
|
get_local 0
|
|
get_local 1
|
|
f32.mul)
|
|
(func (;3;) (type 0) (param f32 f32) (result f32)
|
|
get_local 0
|
|
get_local 1
|
|
f32.div)
|
|
(func (;4;) (type 1) (param f32) (result f32)
|
|
get_local 0
|
|
f32.sqrt)
|
|
(func (;5;) (type 1) (param f32) (result f32)
|
|
get_local 0
|
|
f32.abs)
|
|
(func (;6;) (type 1) (param f32) (result f32)
|
|
get_local 0
|
|
f32.neg)
|
|
(func (;7;) (type 0) (param f32 f32) (result f32)
|
|
get_local 0
|
|
get_local 1
|
|
f32.copysign)
|
|
(func (;8;) (type 1) (param f32) (result f32)
|
|
get_local 0
|
|
f32.ceil)
|
|
(func (;9;) (type 1) (param f32) (result f32)
|
|
get_local 0
|
|
f32.floor)
|
|
(func (;10;) (type 1) (param f32) (result f32)
|
|
get_local 0
|
|
f32.trunc)
|
|
(func (;11;) (type 1) (param f32) (result f32)
|
|
get_local 0
|
|
f32.nearest)
|
|
(func (;12;) (type 0) (param f32 f32) (result f32)
|
|
get_local 0
|
|
get_local 1
|
|
f32.min)
|
|
(func (;13;) (type 0) (param f32 f32) (result f32)
|
|
get_local 0
|
|
get_local 1
|
|
f32.max)
|
|
(func (;14;) (type 2) (param f64 f64) (result f64)
|
|
get_local 0
|
|
get_local 1
|
|
f64.add)
|
|
(func (;15;) (type 2) (param f64 f64) (result f64)
|
|
get_local 0
|
|
get_local 1
|
|
f64.sub)
|
|
(func (;16;) (type 2) (param f64 f64) (result f64)
|
|
get_local 0
|
|
get_local 1
|
|
f64.mul)
|
|
(func (;17;) (type 2) (param f64 f64) (result f64)
|
|
get_local 0
|
|
get_local 1
|
|
f64.div)
|
|
(func (;18;) (type 3) (param f64) (result f64)
|
|
get_local 0
|
|
f64.sqrt)
|
|
(func (;19;) (type 3) (param f64) (result f64)
|
|
get_local 0
|
|
f64.abs)
|
|
(func (;20;) (type 3) (param f64) (result f64)
|
|
get_local 0
|
|
f64.neg)
|
|
(func (;21;) (type 2) (param f64 f64) (result f64)
|
|
get_local 0
|
|
get_local 1
|
|
f64.copysign)
|
|
(func (;22;) (type 3) (param f64) (result f64)
|
|
get_local 0
|
|
f64.ceil)
|
|
(func (;23;) (type 3) (param f64) (result f64)
|
|
get_local 0
|
|
f64.floor)
|
|
(func (;24;) (type 3) (param f64) (result f64)
|
|
get_local 0
|
|
f64.trunc)
|
|
(func (;25;) (type 3) (param f64) (result f64)
|
|
get_local 0
|
|
f64.nearest)
|
|
(func (;26;) (type 2) (param f64 f64) (result f64)
|
|
get_local 0
|
|
get_local 1
|
|
f64.min)
|
|
(func (;27;) (type 2) (param f64 f64) (result f64)
|
|
get_local 0
|
|
get_local 1
|
|
f64.max)
|
|
(export \"f32.add\" (func 0))
|
|
(export \"f32.sub\" (func 1))
|
|
(export \"f32.mul\" (func 2))
|
|
(export \"f32.div\" (func 3))
|
|
(export \"f32.sqrt\" (func 4))
|
|
(export \"f32.abs\" (func 5))
|
|
(export \"f32.neg\" (func 6))
|
|
(export \"f32.copysign\" (func 7))
|
|
(export \"f32.ceil\" (func 8))
|
|
(export \"f32.floor\" (func 9))
|
|
(export \"f32.trunc\" (func 10))
|
|
(export \"f32.nearest\" (func 11))
|
|
(export \"f32.min\" (func 12))
|
|
(export \"f32.max\" (func 13))
|
|
(export \"f64.add\" (func 14))
|
|
(export \"f64.sub\" (func 15))
|
|
(export \"f64.mul\" (func 16))
|
|
(export \"f64.div\" (func 17))
|
|
(export \"f64.sqrt\" (func 18))
|
|
(export \"f64.abs\" (func 19))
|
|
(export \"f64.neg\" (func 20))
|
|
(export \"f64.copysign\" (func 21))
|
|
(export \"f64.ceil\" (func 22))
|
|
(export \"f64.floor\" (func 23))
|
|
(export \"f64.trunc\" (func 24))
|
|
(export \"f64.nearest\" (func 25))
|
|
(export \"f64.min\" (func 26))
|
|
(export \"f64.max\" (func 27)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
fn start_module_1(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
result_object.instance.start(&vm_context);
|
|
}
|
|
|
|
// Line 50
|
|
fn c1_l50_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c1_l50_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.1234568 as f32, 0.00000000012345 as f32, &vm_context);
|
|
assert_eq!(result, 1.1234568 as f32);
|
|
}
|
|
|
|
// Line 51
|
|
fn c2_l51_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c2_l51_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.123456789 as f64, 0.00000000012345 as f64, &vm_context);
|
|
assert_eq!(result, 1.12345678912345 as f64);
|
|
}
|
|
|
|
// Line 55
|
|
fn c3_l55_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c3_l55_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f32, 0.000000059604645 as f32, &vm_context);
|
|
assert_eq!(result, 1.0 as f32);
|
|
}
|
|
|
|
// Line 56
|
|
fn c4_l56_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c4_l56_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f32, 0.00000005960465 as f32, &vm_context);
|
|
assert_eq!(result, 1.0000001 as f32);
|
|
}
|
|
|
|
// Line 57
|
|
fn c5_l57_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c5_l57_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f64, 0.00000000000000011102230246251565 as f64, &vm_context);
|
|
assert_eq!(result, 1.0 as f64);
|
|
}
|
|
|
|
// Line 58
|
|
fn c6_l58_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c6_l58_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f64, 0.00000000000000011102230246251568 as f64, &vm_context);
|
|
assert_eq!(result, 1.0000000000000002 as f64);
|
|
}
|
|
|
|
// Line 61
|
|
fn c7_l61_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c7_l61_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000001 as f32, 0.000000000000000000000000000000000000011754942 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000011754944 as f32);
|
|
}
|
|
|
|
// Line 62
|
|
fn c8_l62_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c8_l62_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 as f64);
|
|
}
|
|
|
|
// Line 67
|
|
fn c9_l67_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c9_l67_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(2147483600.0 as f32, 1024.25 as f32, &vm_context);
|
|
assert_eq!(result, 2147484700.0 as f32);
|
|
}
|
|
|
|
// Line 68
|
|
fn c10_l68_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c10_l68_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(9223372036854776000.0 as f64, 1024.25 as f64, &vm_context);
|
|
assert_eq!(result, 9223372036854778000.0 as f64);
|
|
}
|
|
|
|
// Line 72
|
|
fn c11_l72_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c11_l72_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003645561009778199 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000292 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036455610097781983 as f64);
|
|
}
|
|
|
|
// Line 75
|
|
fn c12_l75_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c12_l75_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(9007199254740992.0 as f64, 1.00001 as f64, &vm_context);
|
|
assert_eq!(result, 9007199254740994.0 as f64);
|
|
}
|
|
|
|
// Line 78
|
|
fn c13_l78_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c13_l78_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(9007199254740994.0 as f64, 0.9999847412109375 as f64, &vm_context);
|
|
assert_eq!(result, 9007199254740994.0 as f64);
|
|
}
|
|
|
|
// Line 81
|
|
fn c14_l81_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c14_l81_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(8388608.0 as f32, 0.5 as f32, &vm_context);
|
|
assert_eq!(result, 8388608.0 as f32);
|
|
}
|
|
|
|
// Line 82
|
|
fn c15_l82_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c15_l82_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(8388609.0 as f32, 0.5 as f32, &vm_context);
|
|
assert_eq!(result, 8388610.0 as f32);
|
|
}
|
|
|
|
// Line 83
|
|
fn c16_l83_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c16_l83_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4503599627370496.0 as f64, 0.5 as f64, &vm_context);
|
|
assert_eq!(result, 4503599627370496.0 as f64);
|
|
}
|
|
|
|
// Line 84
|
|
fn c17_l84_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c17_l84_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4503599627370497.0 as f64, 0.5 as f64, &vm_context);
|
|
assert_eq!(result, 4503599627370498.0 as f64);
|
|
}
|
|
|
|
// Line 87
|
|
fn c18_l87_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c18_l87_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-6207600000000000000000000000000.0 as f32, 0.000000000000000000000000000002309799 as f32, &vm_context);
|
|
assert_eq!(result, -6207600000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 88
|
|
fn c19_l88_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c19_l88_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(209865800000000000000.0 as f32, -5270152500000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 209860530000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 89
|
|
fn c20_l89_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c20_l89_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000001963492 as f32, 0.000000000000000000000000000000000000046220067 as f32, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000001963492 as f32);
|
|
}
|
|
|
|
// Line 90
|
|
fn c21_l90_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c21_l90_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(640905000000.0 as f32, -64449550000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, -64448910000000000.0 as f32);
|
|
}
|
|
|
|
// Line 91
|
|
fn c22_l91_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c22_l91_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000601966 as f32, 120372790000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 120372790000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 92
|
|
fn c23_l92_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c23_l92_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009218993827002741 as f64, -1283078243878048500000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -1283078243878048500000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 93
|
|
fn c24_l93_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c24_l93_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-96503407870148960000000.0 as f64, 0.00000000000000000000000000000000000000000000000000000004670208988478548 as f64, &vm_context);
|
|
assert_eq!(result, -96503407870148960000000.0 as f64);
|
|
}
|
|
|
|
// Line 94
|
|
fn c25_l94_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c25_l94_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000000000000000000000000028559147675434106 as f64, -0.00026124280570653086 as f64, &vm_context);
|
|
assert_eq!(result, -0.00026124280570653086 as f64);
|
|
}
|
|
|
|
// Line 95
|
|
fn c26_l95_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c26_l95_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(417909928165296700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 79335564741512700000.0 as f64, &vm_context);
|
|
assert_eq!(result, 417909928165296700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 96
|
|
fn c27_l96_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c27_l96_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(8265442868747023000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 43603327839006250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 43603327839006250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 99
|
|
fn c28_l99_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c28_l99_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(5238404000000000000000.0 as f32, -1570182.5 as f32, &vm_context);
|
|
assert_eq!(result, 5238404000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 100
|
|
fn c29_l100_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c29_l100_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000004258938 as f32, -0.0000000000000000000000057092353 as f32, &vm_context);
|
|
assert_eq!(result, 0.00000000000004258938 as f32);
|
|
}
|
|
|
|
// Line 101
|
|
fn c30_l101_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c30_l101_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.00000000000027251026 as f32, 83711560000000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 83711560000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 102
|
|
fn c31_l102_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c31_l102_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000000884536 as f32, -0.000000000000000000000000000000015165626 as f32, &vm_context);
|
|
assert_eq!(result, -0.0000000000000884536 as f32);
|
|
}
|
|
|
|
// Line 103
|
|
fn c32_l103_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c32_l103_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0010521035 as f32, -0.000000000000000000000000000000007582135 as f32, &vm_context);
|
|
assert_eq!(result, 0.0010521035 as f32);
|
|
}
|
|
|
|
// Line 104
|
|
fn c33_l104_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c33_l104_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1511135228188924600000000000000000000000000000000000000.0 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002760218100603169 as f64, &vm_context);
|
|
assert_eq!(result, 1511135228188924600000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 105
|
|
fn c34_l105_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c34_l105_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(62386719760360280000000000000000000000000000000.0 as f64, -0.0000000000000000008592185488839212 as f64, &vm_context);
|
|
assert_eq!(result, 62386719760360280000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 106
|
|
fn c35_l106_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c35_l106_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004195022848436354 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029225342022551453 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004195022848436354 as f64);
|
|
}
|
|
|
|
// Line 107
|
|
fn c36_l107_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c36_l107_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-215220546714824520000000000000000000000000000.0 as f64, -1112220412047137200000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -216332767126871650000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 108
|
|
fn c37_l108_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c37_l108_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-13.6911535055856 as f64, 2066117898924419800000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 2066117898924419800000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 111
|
|
fn c38_l111_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c38_l111_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000006456021 as f32, 0.00000000000020219949 as f32, &vm_context);
|
|
assert_eq!(result, 0.00000000000020219949 as f32);
|
|
}
|
|
|
|
// Line 112
|
|
fn c39_l112_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c39_l112_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000026823169 as f32, 0.000000011196016 as f32, &vm_context);
|
|
assert_eq!(result, -0.000026811973 as f32);
|
|
}
|
|
|
|
// Line 113
|
|
fn c40_l113_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c40_l113_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-128526170000.0 as f32, 0.0000000000000000000000000000000027356305 as f32, &vm_context);
|
|
assert_eq!(result, -128526170000.0 as f32);
|
|
}
|
|
|
|
// Line 114
|
|
fn c41_l114_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c41_l114_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000004158973 as f32, -1573528700.0 as f32, &vm_context);
|
|
assert_eq!(result, -1573528700.0 as f32);
|
|
}
|
|
|
|
// Line 115
|
|
fn c42_l115_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c42_l115_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000000000000000000000000000009338769 as f32, 78647514000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 78647514000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 116
|
|
fn c43_l116_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c43_l116_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021986596650683218 as f64, -235447594845461340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -235447594845461340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 117
|
|
fn c44_l117_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c44_l117_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-314175619593595700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -30114098514611660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -314175649707694230000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 118
|
|
fn c45_l118_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c45_l118_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013722858367681836 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000011571842749688977 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000011571842749688977 as f64);
|
|
}
|
|
|
|
// Line 119
|
|
fn c46_l119_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c46_l119_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009828583756551075 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016862581574752944 as f64, &vm_context);
|
|
assert_eq!(result, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009828583756551075 as f64);
|
|
}
|
|
|
|
// Line 120
|
|
fn c47_l120_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c47_l120_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-672584203522163500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 8374007930974482000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -672584203522163500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 123
|
|
fn c48_l123_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c48_l123_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-210896605327889950000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 581483233421196300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 581483022524591100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 124
|
|
fn c49_l124_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c49_l124_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(102315792666821480000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 450204300797494900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 102315792667271680000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 125
|
|
fn c50_l125_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c50_l125_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-130529978570956560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 154899434220186570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 154899434220186450000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 126
|
|
fn c51_l126_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c51_l126_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(47629997434721684000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 455586451058259700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 455586451058259700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 127
|
|
fn c52_l127_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c52_l127_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003958952516558414 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023092460710062946 as f64, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000230924607140219 as f64);
|
|
}
|
|
|
|
// Line 130
|
|
fn c53_l130_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c53_l130_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-43780558475415996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -49680759347383435000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -49680759347383435000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 131
|
|
fn c54_l131_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c54_l131_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(21174311168546080000000000000000000000000000000000000000000.0 as f64, -26385928474612128000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -26385928474612128000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 132
|
|
fn c55_l132_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c55_l132_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-9508489561700635000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007858068235728165 as f64, &vm_context);
|
|
assert_eq!(result, -9508489561700635000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 133
|
|
fn c56_l133_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c56_l133_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005079144928553737 as f64, -354021720742499800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -354021720742499800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 134
|
|
fn c57_l134_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c57_l134_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000004165382103988111 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010865942283516648 as f64, &vm_context);
|
|
assert_eq!(result, -0.000000000000000000000000000000000000000000000000000000000004165382103988111 as f64);
|
|
}
|
|
|
|
// Line 137
|
|
fn c58_l137_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c58_l137_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(97215650000000000000000000000000000.0 as f32, 305590870000000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 305688080000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 138
|
|
fn c59_l138_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c59_l138_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(270465630000000000000000000000000000000.0 as f32, -230236850000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 270465400000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 139
|
|
fn c60_l139_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c60_l139_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(357209300000000000000000000000000000.0 as f32, -236494050000000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, -236136840000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 140
|
|
fn c61_l140_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c61_l140_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-1484234100000000000000000000000000000.0 as f32, -328991400000000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, -330475620000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 141
|
|
fn c62_l141_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c62_l141_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-219885600000000000000000000000000000000.0 as f32, -81560930000000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, -301446520000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 142
|
|
fn c63_l142_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c63_l142_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(90390204939547630000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 22943337422040356000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 90390204939570580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 143
|
|
fn c64_l143_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c64_l143_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(165916059736246050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 12577349331444160000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 165916059748823400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 144
|
|
fn c65_l144_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c65_l144_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-136351292561394300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 60507030603873580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -136290785530790440000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 145
|
|
fn c66_l145_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c66_l145_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-34377613258227424000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 169947152758793490000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 169947118381180220000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 146
|
|
fn c67_l146_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c67_l146_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(92273427008645570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -39269416451018680000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 92273426969376150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 149
|
|
fn c68_l149_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c68_l149_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000008313455 as f32, 0.000000000000000000000000000000000000000000873 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000008314328 as f32);
|
|
}
|
|
|
|
// Line 150
|
|
fn c69_l150_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c69_l150_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000052 as f32, -0.000000000000000000000000000000000000000000003 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000049 as f32);
|
|
}
|
|
|
|
// Line 151
|
|
fn c70_l151_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c70_l151_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000011 as f32, 0.000000000000000000000000000000000000005186284 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000005186273 as f32);
|
|
}
|
|
|
|
// Line 152
|
|
fn c71_l152_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c71_l152_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000028 as f32, 0.00000000000000000000000000000000000023675283 as f32, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000000000000000002367528 as f32);
|
|
}
|
|
|
|
// Line 153
|
|
fn c72_l153_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c72_l153_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000635 as f32, -0.00000000000000000000000000000000000000003327 as f32, &vm_context);
|
|
assert_eq!(result, -0.000000000000000000000000000000000000000032635 as f32);
|
|
}
|
|
|
|
// Line 154
|
|
fn c73_l154_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c73_l154_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028461489375936755 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005130160608603642 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002284011671009967 as f64);
|
|
}
|
|
|
|
// Line 155
|
|
fn c74_l155_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c74_l155_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047404811354775 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008895417776504167 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004154936641026667 as f64);
|
|
}
|
|
|
|
// Line 156
|
|
fn c75_l156_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c75_l156_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009330082001250494 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029863980609419717 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003919406261067021 as f64);
|
|
}
|
|
|
|
// Line 157
|
|
fn c76_l157_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c76_l157_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014418693884494008 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016324914377759187 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001906220493265178 as f64);
|
|
}
|
|
|
|
// Line 158
|
|
fn c77_l158_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c77_l158_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043203619362281506 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002521511966399844 as f64, &vm_context);
|
|
assert_eq!(result, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017988499698283067 as f64);
|
|
}
|
|
|
|
// Line 162
|
|
fn c78_l162_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c78_l162_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(340282330000000000000000000000000000000.0 as f32, 20282410000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 340282350000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 163
|
|
fn c79_l163_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c79_l163_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 19958403095347200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 166
|
|
fn c80_l166_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c80_l166_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(2.0 as f32, 2.0 as f32, &vm_context);
|
|
assert_eq!(result, 4.0 as f32);
|
|
}
|
|
|
|
// Line 167
|
|
fn c81_l167_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c81_l167_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(2.0 as f64, 2.0 as f64, &vm_context);
|
|
assert_eq!(result, 4.0 as f64);
|
|
}
|
|
|
|
// Line 170
|
|
fn c82_l170_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c82_l170_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(340282350000000000000000000000000000000.0 as f32, 10141204000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 340282350000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 171
|
|
fn c83_l171_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c83_l171_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(340282350000000000000000000000000000000.0 as f32, 10141205000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, f32::INFINITY);
|
|
}
|
|
|
|
// Line 172
|
|
fn c84_l172_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c84_l172_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 9979201547673598000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 173
|
|
fn c85_l173_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c85_l173_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.add") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 9979201547673600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, f64::INFINITY);
|
|
}
|
|
|
|
// Line 177
|
|
fn c86_l177_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c86_l177_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(65536.0 as f32, 0.000000000007275958 as f32, &vm_context);
|
|
assert_eq!(result, 65536.0 as f32);
|
|
}
|
|
|
|
// Line 178
|
|
fn c87_l178_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c87_l178_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(65536.0 as f64, 0.000000000007275957614183426 as f64, &vm_context);
|
|
assert_eq!(result, 65535.99999999999 as f64);
|
|
}
|
|
|
|
// Line 182
|
|
fn c88_l182_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c88_l182_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f32, 0.000000029802322 as f32, &vm_context);
|
|
assert_eq!(result, 1.0 as f32);
|
|
}
|
|
|
|
// Line 183
|
|
fn c89_l183_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c89_l183_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f32, 0.000000029802326 as f32, &vm_context);
|
|
assert_eq!(result, 0.99999994 as f32);
|
|
}
|
|
|
|
// Line 184
|
|
fn c90_l184_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c90_l184_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f64, 0.00000000000000005551115123125783 as f64, &vm_context);
|
|
assert_eq!(result, 1.0 as f64);
|
|
}
|
|
|
|
// Line 185
|
|
fn c91_l185_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c91_l185_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f64, 0.00000000000000005551115123125784 as f64, &vm_context);
|
|
assert_eq!(result, 0.9999999999999999 as f64);
|
|
}
|
|
|
|
// Line 188
|
|
fn c92_l188_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c92_l188_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000002379208 as f32, -722129800000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 722129800000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 189
|
|
fn c93_l189_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c93_l189_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-842284000000000000000000000000000000.0 as f32, -11118414000000.0 as f32, &vm_context);
|
|
assert_eq!(result, -842284000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 190
|
|
fn c94_l190_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c94_l190_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.4549444 as f32, -0.00000000000000000000000033792615 as f32, &vm_context);
|
|
assert_eq!(result, 1.4549444 as f32);
|
|
}
|
|
|
|
// Line 191
|
|
fn c95_l191_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c95_l191_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000000000000000094808914 as f32, 0.000000000000000000000018589502 as f32, &vm_context);
|
|
assert_eq!(result, -0.000000000000000000000018589502 as f32);
|
|
}
|
|
|
|
// Line 192
|
|
fn c96_l192_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c96_l192_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000006181167 as f32, -0.0000000000000000000000000000000093959864 as f32, &vm_context);
|
|
assert_eq!(result, 0.000006181167 as f32);
|
|
}
|
|
|
|
// Line 193
|
|
fn c97_l193_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c97_l193_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000775701650124413 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002524845082116609 as f64, &vm_context);
|
|
assert_eq!(result, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000775701650124413 as f64);
|
|
}
|
|
|
|
// Line 194
|
|
fn c98_l194_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c98_l194_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-20991871064832710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -0.0000000000000000000000000000000000000000000000038165079778426864 as f64, &vm_context);
|
|
assert_eq!(result, -20991871064832710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 195
|
|
fn c99_l195_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c99_l195_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028592030964162332 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020889465194336087 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000028592030964162332 as f64);
|
|
}
|
|
|
|
// Line 196
|
|
fn c100_l196_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c100_l196_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000303879528930943 as f64, -23204941114021897000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 23204941114021897000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 197
|
|
fn c101_l197_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c101_l197_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.00000000000000000000000000000000000000000014953904039036317 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010592252695645683 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000014953904039036317 as f64);
|
|
}
|
|
|
|
// Line 200
|
|
fn c102_l200_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c102_l200_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-448601660000000000000000000000000.0 as f32, -8984148000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 8535546400000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 201
|
|
fn c103_l201_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c103_l201_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-899427400000000000000000000000000.0 as f32, 91.579384 as f32, &vm_context);
|
|
assert_eq!(result, -899427400000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 202
|
|
fn c104_l202_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c104_l202_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.00000000000000000000000011975 as f32, 0.000000063140405 as f32, &vm_context);
|
|
assert_eq!(result, -0.000000063140405 as f32);
|
|
}
|
|
|
|
// Line 203
|
|
fn c105_l203_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c105_l203_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000011800487 as f32, -0.00031558736 as f32, &vm_context);
|
|
assert_eq!(result, 0.00031558736 as f32);
|
|
}
|
|
|
|
// Line 204
|
|
fn c106_l204_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c106_l204_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-736483800000000000000000000000.0 as f32, 0.0000000000000000030824513 as f32, &vm_context);
|
|
assert_eq!(result, -736483800000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 205
|
|
fn c107_l205_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c107_l205_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-9410469964196796000000000000000000000000000000000000000000000.0 as f64, -17306275691385970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 17306275691385970000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 206
|
|
fn c108_l206_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c108_l206_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002877908564233173 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002339448785991429 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002877908564233173 as f64);
|
|
}
|
|
|
|
// Line 207
|
|
fn c109_l207_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c109_l207_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000009719219783531962 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001572015082308034 as f64, &vm_context);
|
|
assert_eq!(result, -0.0000000000000000000000000000000000000000000000000000000000009719219783531962 as f64);
|
|
}
|
|
|
|
// Line 208
|
|
fn c110_l208_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c110_l208_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034908896031751274 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019928479721303208 as f64, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019928479721303208 as f64);
|
|
}
|
|
|
|
// Line 209
|
|
fn c111_l209_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c111_l209_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-7538298763725556000000000000000000.0 as f64, 4447012580193329000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -4447012580193329000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 212
|
|
fn c112_l212_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c112_l212_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(75846976000000000000000000000.0 as f32, 0.000046391753 as f32, &vm_context);
|
|
assert_eq!(result, 75846976000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 213
|
|
fn c113_l213_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c113_l213_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-567139.9 as f32, -0.000000000030334842 as f32, &vm_context);
|
|
assert_eq!(result, -567139.9 as f32);
|
|
}
|
|
|
|
// Line 214
|
|
fn c114_l214_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c114_l214_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000017412261 as f32, -0.000000000000000017877793 as f32, &vm_context);
|
|
assert_eq!(result, -0.000000000017412244 as f32);
|
|
}
|
|
|
|
// Line 215
|
|
fn c115_l215_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c115_l215_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000065645545 as f32, 0.00014473806 as f32, &vm_context);
|
|
assert_eq!(result, -0.00021038362 as f32);
|
|
}
|
|
|
|
// Line 216
|
|
fn c116_l216_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c116_l216_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.00000000016016115 as f32, -0.000000000000000000000000000000085380075 as f32, &vm_context);
|
|
assert_eq!(result, -0.00000000016016115 as f32);
|
|
}
|
|
|
|
// Line 217
|
|
fn c117_l217_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c117_l217_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000000009358725267183177 as f64, -31137147338685164000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 31137147338685164000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 218
|
|
fn c118_l218_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c118_l218_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-4390767596767215000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -67890457158958560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 67890457158958560000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 219
|
|
fn c119_l219_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c119_l219_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036288281010831153 as f64, 3383199683245004400000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -3383199683245004400000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 220
|
|
fn c120_l220_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c120_l220_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003645097751812619 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031423490969686624 as f64, &vm_context);
|
|
assert_eq!(result, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031423491006137603 as f64);
|
|
}
|
|
|
|
// Line 221
|
|
fn c121_l221_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c121_l221_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008021529638989887 as f64, -0.00006774972769072139 as f64, &vm_context);
|
|
assert_eq!(result, 0.00006774972769072139 as f64);
|
|
}
|
|
|
|
// Line 224
|
|
fn c122_l224_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c122_l224_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000005816988065793039 as f64, 0.000000000000000000000000000000000025021499241540866 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000005816988065768018 as f64);
|
|
}
|
|
|
|
// Line 225
|
|
fn c123_l225_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c123_l225_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043336683304809554 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016945582607476316 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043336683135353726 as f64);
|
|
}
|
|
|
|
// Line 226
|
|
fn c124_l226_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c124_l226_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000006908052676315257 as f64, 0.0000000000000000000000000000000000000000000000000000000000012001773734799856 as f64, &vm_context);
|
|
assert_eq!(result, -0.0000000000000000000000000000000000000000000000000000000000012001773734799856 as f64);
|
|
}
|
|
|
|
// Line 227
|
|
fn c125_l227_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c125_l227_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000022044291547443813 as f64, -0.0000000000000000000027947429925618632 as f64, &vm_context);
|
|
assert_eq!(result, -0.000000000002204429151949638 as f64);
|
|
}
|
|
|
|
// Line 228
|
|
fn c126_l228_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c126_l228_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000004016393569117761 as f64, 0.17053881989395447 as f64, &vm_context);
|
|
assert_eq!(result, -0.17053877973001877 as f64);
|
|
}
|
|
|
|
// Line 231
|
|
fn c127_l231_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c127_l231_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010015106898667285 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004785375958943186 as f64, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000047853759589431757 as f64);
|
|
}
|
|
|
|
// Line 232
|
|
fn c128_l232_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c128_l232_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-15618959953.641388 as f64, 598234410620718900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -598234410620718900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 233
|
|
fn c129_l233_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c129_l233_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(38832071540376680000000000000000000.0 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042192279274320304 as f64, &vm_context);
|
|
assert_eq!(result, 38832071540376680000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 234
|
|
fn c130_l234_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c130_l234_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010705986890807897 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017466607734737216 as f64, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010705986890807897 as f64);
|
|
}
|
|
|
|
// Line 235
|
|
fn c131_l235_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c131_l235_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000949378346261834 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014584885434950294 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000949378346261834 as f64);
|
|
}
|
|
|
|
// Line 239
|
|
fn c132_l239_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c132_l239_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(23.140692 as f32, 3.1415927 as f32, &vm_context);
|
|
assert_eq!(result, 19.9991 as f32);
|
|
}
|
|
|
|
// Line 240
|
|
fn c133_l240_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c133_l240_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(23.14069263277927 as f64, 3.141592653589793 as f64, &vm_context);
|
|
assert_eq!(result, 19.999099979189477 as f64);
|
|
}
|
|
|
|
// Line 243
|
|
fn c134_l243_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c134_l243_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(2999999.0 as f32, 2999998.0 as f32, &vm_context);
|
|
assert_eq!(result, 1.0 as f32);
|
|
}
|
|
|
|
// Line 244
|
|
fn c135_l244_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c135_l244_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1999999.0 as f32, 1999995.0 as f32, &vm_context);
|
|
assert_eq!(result, 4.0 as f32);
|
|
}
|
|
|
|
// Line 245
|
|
fn c136_l245_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c136_l245_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1999999.0 as f32, 1999993.0 as f32, &vm_context);
|
|
assert_eq!(result, 6.0 as f32);
|
|
}
|
|
|
|
// Line 246
|
|
fn c137_l246_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c137_l246_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(400002.0 as f32, 400001.0 as f32, &vm_context);
|
|
assert_eq!(result, 1.0 as f32);
|
|
}
|
|
|
|
// Line 247
|
|
fn c138_l247_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c138_l247_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(400002.0 as f32, 400000.0 as f32, &vm_context);
|
|
assert_eq!(result, 2.0 as f32);
|
|
}
|
|
|
|
// Line 248
|
|
fn c139_l248_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c139_l248_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(2999999999999999.0 as f64, 2999999999999998.0 as f64, &vm_context);
|
|
assert_eq!(result, 1.0 as f64);
|
|
}
|
|
|
|
// Line 249
|
|
fn c140_l249_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c140_l249_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1999999999999999.0 as f64, 1999999999999995.0 as f64, &vm_context);
|
|
assert_eq!(result, 4.0 as f64);
|
|
}
|
|
|
|
// Line 250
|
|
fn c141_l250_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c141_l250_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1999999999999999.0 as f64, 1999999999999993.0 as f64, &vm_context);
|
|
assert_eq!(result, 6.0 as f64);
|
|
}
|
|
|
|
// Line 251
|
|
fn c142_l251_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c142_l251_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(400000000000002.0 as f64, 400000000000001.0 as f64, &vm_context);
|
|
assert_eq!(result, 1.0 as f64);
|
|
}
|
|
|
|
// Line 252
|
|
fn c143_l252_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c143_l252_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(400000000000002.0 as f64, 400000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 2.0 as f64);
|
|
}
|
|
|
|
// Line 255
|
|
fn c144_l255_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c144_l255_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000011754944 as f32, 0.000000000000000000000000000000000000011754942 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000001 as f32);
|
|
}
|
|
|
|
// Line 256
|
|
fn c145_l256_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c145_l256_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005 as f64);
|
|
}
|
|
|
|
// Line 259
|
|
fn c146_l259_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c146_l259_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000001 as f32, 0.99999994 as f32, &vm_context);
|
|
assert_eq!(result, 0.00000017881393 as f32);
|
|
}
|
|
|
|
// Line 260
|
|
fn c147_l260_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c147_l260_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000001 as f32, 1.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.00000011920929 as f32);
|
|
}
|
|
|
|
// Line 261
|
|
fn c148_l261_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c148_l261_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f32, 0.99999994 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000059604645 as f32);
|
|
}
|
|
|
|
// Line 262
|
|
fn c149_l262_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c149_l262_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000000000000002 as f64, 0.9999999999999999 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000033306690738754696 as f64);
|
|
}
|
|
|
|
// Line 263
|
|
fn c150_l263_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c150_l263_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000000000000002 as f64, 1.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.0000000000000002220446049250313 as f64);
|
|
}
|
|
|
|
// Line 264
|
|
fn c151_l264_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c151_l264_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f64, 0.9999999999999999 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000011102230246251565 as f64);
|
|
}
|
|
|
|
// Line 268
|
|
fn c152_l268_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c152_l268_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(340282350000000000000000000000000000000.0 as f32, 10141204000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 340282350000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 269
|
|
fn c153_l269_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c153_l269_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(340282350000000000000000000000000000000.0 as f32, 10141205000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 340282330000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 270
|
|
fn c154_l270_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c154_l270_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 9979201547673598000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 271
|
|
fn c155_l271_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c155_l271_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sub") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 9979201547673600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 274
|
|
fn c156_l274_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c156_l274_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1000000000000000.0 as f32, 1000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 999999940000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 275
|
|
fn c157_l275_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c157_l275_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(100000000000000000000.0 as f32, 100000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, f32::INFINITY);
|
|
}
|
|
|
|
// Line 276
|
|
fn c158_l276_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c158_l276_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(10000000000000000000000000.0 as f32, 10000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, f32::INFINITY);
|
|
}
|
|
|
|
// Line 277
|
|
fn c159_l277_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c159_l277_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1000000000000000.0 as f64, 1000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 1000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 278
|
|
fn c160_l278_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c160_l278_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(100000000000000000000.0 as f64, 100000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 10000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 279
|
|
fn c161_l279_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c161_l279_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(10000000000000000000000000.0 as f64, 10000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 100000000000000030000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 284
|
|
fn c162_l284_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c162_l284_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1848874900.0 as f32, 19954563000.0 as f32, &vm_context);
|
|
assert_eq!(result, 36893493000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 285
|
|
fn c163_l285_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c163_l285_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1848874847.0 as f64, 19954562207.0 as f64, &vm_context);
|
|
assert_eq!(result, 36893488147419110000.0 as f64);
|
|
}
|
|
|
|
// Line 289
|
|
fn c164_l289_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c164_l289_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(77.1 as f32, 850.0 as f32, &vm_context);
|
|
assert_eq!(result, 65535.0 as f32);
|
|
}
|
|
|
|
// Line 290
|
|
fn c165_l290_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c165_l290_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(77.1 as f64, 850.0 as f64, &vm_context);
|
|
assert_eq!(result, 65534.99999999999 as f64);
|
|
}
|
|
|
|
// Line 293
|
|
fn c166_l293_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c166_l293_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-2493839400000000000.0 as f32, 0.000000000021176054 as f32, &vm_context);
|
|
assert_eq!(result, -52809680.0 as f32);
|
|
}
|
|
|
|
// Line 294
|
|
fn c167_l294_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c167_l294_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-6777248400000000000000000000000.0 as f32, -0.00000000000000000000000000000034758242 as f32, &vm_context);
|
|
assert_eq!(result, 2.3556523 as f32);
|
|
}
|
|
|
|
// Line 295
|
|
fn c168_l295_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c168_l295_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-8384397600000000000000000000.0 as f32, -0.000000000000000000000000000011948991 as f32, &vm_context);
|
|
assert_eq!(result, 0.10018509 as f32);
|
|
}
|
|
|
|
// Line 296
|
|
fn c169_l296_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c169_l296_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-656765400000000000000000.0 as f32, -0.000000000000000000000046889766 as f32, &vm_context);
|
|
assert_eq!(result, 30.795576 as f32);
|
|
}
|
|
|
|
// Line 297
|
|
fn c170_l297_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c170_l297_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(13328204000000000.0 as f32, 45.567223 as f32, &vm_context);
|
|
assert_eq!(result, 607329200000000000.0 as f32);
|
|
}
|
|
|
|
// Line 298
|
|
fn c171_l298_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c171_l298_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-99426226093342430000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 583177241514245140000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, f64::NEG_INFINITY);
|
|
}
|
|
|
|
// Line 299
|
|
fn c172_l299_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c172_l299_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002748155824301909 as f64, -0.000000000000000000000000000000000000000000000000000000000000000002093035437779455 as f64, &vm_context);
|
|
assert_eq!(result, 0.0 as f64);
|
|
}
|
|
|
|
// Line 300
|
|
fn c173_l300_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c173_l300_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(464888257371302500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -159272886487254360000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -74044094645556960000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 301
|
|
fn c174_l301_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c174_l301_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008261927764172427 as f64, 36684744190529535000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -3030867065492991300000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 302
|
|
fn c175_l302_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c175_l302_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(253838958331769250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007842892881810105 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000019908317594263248 as f64);
|
|
}
|
|
|
|
// Line 305
|
|
fn c176_l305_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c176_l305_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000000000000000000020153333 as f32, -5031353000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 10.139854 as f32);
|
|
}
|
|
|
|
// Line 306
|
|
fn c177_l306_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c177_l306_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(12286325000000000000000.0 as f32, 749601.8 as f32, &vm_context);
|
|
assert_eq!(result, 9209852000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 307
|
|
fn c178_l307_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c178_l307_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000002763514 as f32, -35524714000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 9817304000000.0 as f32);
|
|
}
|
|
|
|
// Line 308
|
|
fn c179_l308_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c179_l308_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(218931220000000000000.0 as f32, -40298.785 as f32, &vm_context);
|
|
assert_eq!(result, -8822662000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 309
|
|
fn c180_l309_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c180_l309_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1691996300.0 as f32, -122103350000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, -206598410000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 310
|
|
fn c181_l310_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c181_l310_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007576316076452304 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004601355879514986 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003486132652344772 as f64);
|
|
}
|
|
|
|
// Line 311
|
|
fn c182_l311_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c182_l311_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000012228616081443885 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008055526185180067 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009850793705258527 as f64);
|
|
}
|
|
|
|
// Line 312
|
|
fn c183_l312_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c183_l312_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-2068651246039250800000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -366801071583254800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, f64::INFINITY);
|
|
}
|
|
|
|
// Line 313
|
|
fn c184_l313_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c184_l313_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1543238835610281000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007370621385787007 as f64, &vm_context);
|
|
assert_eq!(result, 1137462916512617700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 314
|
|
fn c185_l314_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c185_l314_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(2235876566242058700000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -760669005920257000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -1700762005003744000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 317
|
|
fn c186_l317_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c186_l317_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-110087030000000.0 as f32, -54038020000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, f32::INFINITY);
|
|
}
|
|
|
|
// Line 318
|
|
fn c187_l318_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c187_l318_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.19366351 as f32, 0.0000000000000000000000000000029748954 as f32, &vm_context);
|
|
assert_eq!(result, -0.0000000000000000000000000000005761287 as f32);
|
|
}
|
|
|
|
// Line 319
|
|
fn c188_l319_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c188_l319_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000034300713 as f32, 77991523000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, -267516490000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 320
|
|
fn c189_l320_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c189_l320_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-99003850000000000.0 as f32, 0.000000000000000000000000000020933774 as f32, &vm_context);
|
|
assert_eq!(result, -0.0000000000020725242 as f32);
|
|
}
|
|
|
|
// Line 321
|
|
fn c190_l321_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c190_l321_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-129919.07 as f32, 0.0000000000000000000000000000000000018480999 as f32, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000024010342 as f32);
|
|
}
|
|
|
|
// Line 322
|
|
fn c191_l322_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c191_l322_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006625572200844895 as f64, -37374020681740010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000024762427246273877 as f64);
|
|
}
|
|
|
|
// Line 323
|
|
fn c192_l323_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c192_l323_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(821076848561758000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012976552328552289 as f64, &vm_context);
|
|
assert_eq!(result, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000010654746691124455 as f64);
|
|
}
|
|
|
|
// Line 324
|
|
fn c193_l324_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c193_l324_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-10223449294906041000000000000000000000000000000000000.0 as f64, 1970855583334680500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -20148942123804574000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 325
|
|
fn c194_l325_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c194_l325_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(2918243080119086000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -63633170941689700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, f64::NEG_INFINITY);
|
|
}
|
|
|
|
// Line 326
|
|
fn c195_l326_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c195_l326_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(3407037798802672000000000.0 as f64, 1225791423971563000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 4176317714919266400000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 329
|
|
fn c196_l329_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c196_l329_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044091927284399547 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011518840702296592 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005078878866462432 as f64);
|
|
}
|
|
|
|
// Line 330
|
|
fn c197_l330_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c197_l330_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.002980041826472432 as f64, 63125412993218000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -188116371033135940000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 331
|
|
fn c198_l331_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c198_l331_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-308344578081300100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010081049555008529 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000031084369716557833 as f64);
|
|
}
|
|
|
|
// Line 332
|
|
fn c199_l332_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c199_l332_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(349387501315677300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 2131316915930809900.0 as f64, &vm_context);
|
|
assert_eq!(result, 744655491768901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 333
|
|
fn c200_l333_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c200_l333_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000012500108005100234 as f64, 1035265704160467500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -12940933115981990000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 336
|
|
fn c201_l336_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c201_l336_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008947461661755698 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020853844141312436 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018658897095462173 as f64);
|
|
}
|
|
|
|
// Line 337
|
|
fn c202_l337_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c202_l337_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.00000000000000001161813037330394 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018737038135583668 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021768935186877886 as f64);
|
|
}
|
|
|
|
// Line 338
|
|
fn c203_l338_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c203_l338_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021752326768352433 as f64, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006631210068072052 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014424424827029184 as f64);
|
|
}
|
|
|
|
// Line 339
|
|
fn c204_l339_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c204_l339_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007149518157441743 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000022770445062365393 as f64, &vm_context);
|
|
assert_eq!(result, -0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001627977104264113 as f64);
|
|
}
|
|
|
|
// Line 340
|
|
fn c205_l340_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c205_l340_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004817739302150786 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000025375023049719763 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012225024583961697 as f64);
|
|
}
|
|
|
|
// Line 343
|
|
fn c206_l343_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c206_l343_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(46576441629501554000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007021344893525714 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000003270292605938992 as f64);
|
|
}
|
|
|
|
// Line 344
|
|
fn c207_l344_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c207_l344_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.012451716278313712 as f64, 0.000000000000000000000000000000000000000000001945309177849331 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000000000000000000000000000000002422243795617958 as f64);
|
|
}
|
|
|
|
// Line 345
|
|
fn c208_l345_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c208_l345_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-3.8312314777598586 as f64, 0.0000000000009039887741742674 as f64, &vm_context);
|
|
assert_eq!(result, -0.0000000000034633902471580017 as f64);
|
|
}
|
|
|
|
// Line 346
|
|
fn c209_l346_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c209_l346_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009843582638849689 as f64, 0.00000000000000000000000000000000000000000000000000000000000003375405654777583 as f64, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000033226084502443684 as f64);
|
|
}
|
|
|
|
// Line 347
|
|
fn c210_l347_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c210_l347_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-260544537094514460000000.0 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000032887528185809035 as f64, &vm_context);
|
|
assert_eq!(result, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000008568665807354412 as f64);
|
|
}
|
|
|
|
// Line 350
|
|
fn c211_l350_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c211_l350_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000002646978 as f32, 0.00000000000000000000002646978 as f32, &vm_context);
|
|
assert_eq!(result, 0.0 as f32);
|
|
}
|
|
|
|
// Line 351
|
|
fn c212_l351_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c212_l351_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000026469783 as f32, 0.000000000000000000000026469783 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000001 as f32);
|
|
}
|
|
|
|
// Line 352
|
|
fn c213_l352_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c213_l352_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026285 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026285 as f64, &vm_context);
|
|
assert_eq!(result, 0.0 as f64);
|
|
}
|
|
|
|
// Line 353
|
|
fn c214_l353_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c214_l353_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026288 as f64, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015717277847026288 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005 as f64);
|
|
}
|
|
|
|
// Line 356
|
|
fn c215_l356_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c215_l356_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(18446743000000000000.0 as f32, 18446743000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 340282330000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 357
|
|
fn c216_l357_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c216_l357_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(18446744000000000000.0 as f32, 18446744000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, f32::INFINITY);
|
|
}
|
|
|
|
// Line 358
|
|
fn c217_l358_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c217_l358_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 13407807929942596000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 179769313486231550000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 359
|
|
fn c218_l359_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c218_l359_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(13407807929942597000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 13407807929942597000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, f64::INFINITY);
|
|
}
|
|
|
|
// Line 362
|
|
fn c219_l362_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c219_l362_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000001 as f32, 1.0000001 as f32, &vm_context);
|
|
assert_eq!(result, 1.0000002 as f32);
|
|
}
|
|
|
|
// Line 363
|
|
fn c220_l363_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c220_l363_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.99999994 as f32, 0.99999994 as f32, &vm_context);
|
|
assert_eq!(result, 0.9999999 as f32);
|
|
}
|
|
|
|
// Line 364
|
|
fn c221_l364_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c221_l364_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000000000000002 as f64, 1.0000000000000002 as f64, &vm_context);
|
|
assert_eq!(result, 1.0000000000000004 as f64);
|
|
}
|
|
|
|
// Line 365
|
|
fn c222_l365_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c222_l365_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.9999999999999999 as f64, 0.9999999999999999 as f64, &vm_context);
|
|
assert_eq!(result, 0.9999999999999998 as f64);
|
|
}
|
|
|
|
// Line 368
|
|
fn c223_l368_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c223_l368_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000001 as f32, 0.99999994 as f32, &vm_context);
|
|
assert_eq!(result, 1.0 as f32);
|
|
}
|
|
|
|
// Line 369
|
|
fn c224_l369_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c224_l369_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000002 as f32, 0.9999999 as f32, &vm_context);
|
|
assert_eq!(result, 1.0000001 as f32);
|
|
}
|
|
|
|
// Line 370
|
|
fn c225_l370_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c225_l370_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000000000000002 as f64, 0.9999999999999999 as f64, &vm_context);
|
|
assert_eq!(result, 1.0 as f64);
|
|
}
|
|
|
|
// Line 371
|
|
fn c226_l371_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c226_l371_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000000000000004 as f64, 0.9999999999999998 as f64, &vm_context);
|
|
assert_eq!(result, 1.0000000000000002 as f64);
|
|
}
|
|
|
|
// Line 375
|
|
fn c227_l375_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c227_l375_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000011754944 as f32, 0.00000011920929 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000001 as f32);
|
|
}
|
|
|
|
// Line 376
|
|
fn c228_l376_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c228_l376_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 as f64, 0.0000000000000002220446049250313 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005 as f64);
|
|
}
|
|
|
|
// Line 379
|
|
fn c229_l379_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c229_l379_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.mul") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-16.001465 as f32, 0.000000000000000000000000000000000000000298465 as f32, &vm_context);
|
|
assert_eq!(result, -0.000000000000000000000000000000000000004775883 as f32);
|
|
}
|
|
|
|
// Line 382
|
|
fn c230_l382_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c230_l382_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.1234568 as f32, 100.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.011234568 as f32);
|
|
}
|
|
|
|
// Line 383
|
|
fn c231_l383_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c231_l383_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(8391667.0 as f32, 12582905.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.6669102 as f32);
|
|
}
|
|
|
|
// Line 384
|
|
fn c232_l384_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c232_l384_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(65536.0 as f32, 0.000000000007275958 as f32, &vm_context);
|
|
assert_eq!(result, 9007199000000000.0 as f32);
|
|
}
|
|
|
|
// Line 385
|
|
fn c233_l385_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c233_l385_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.8622957 as f32, 340282350000000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000005472795 as f32);
|
|
}
|
|
|
|
// Line 386
|
|
fn c234_l386_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c234_l386_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4.0 as f32, 3.0 as f32, &vm_context);
|
|
assert_eq!(result, 1.3333334 as f32);
|
|
}
|
|
|
|
// Line 387
|
|
fn c235_l387_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c235_l387_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.123456789 as f64, 100.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.01123456789 as f64);
|
|
}
|
|
|
|
// Line 388
|
|
fn c236_l388_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c236_l388_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(8391667.0 as f64, 12582905.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.6669101451532854 as f64);
|
|
}
|
|
|
|
// Line 389
|
|
fn c237_l389_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c237_l389_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(65536.0 as f64, 0.000000000007275957614183426 as f64, &vm_context);
|
|
assert_eq!(result, 9007199254740992.0 as f64);
|
|
}
|
|
|
|
// Line 390
|
|
fn c238_l390_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c238_l390_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.8622957468032837 as f64, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001035936395755283 as f64);
|
|
}
|
|
|
|
// Line 391
|
|
fn c239_l391_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c239_l391_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4.0 as f64, 3.0 as f64, &vm_context);
|
|
assert_eq!(result, 1.3333333333333333 as f64);
|
|
}
|
|
|
|
// Line 395
|
|
fn c240_l395_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c240_l395_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4195835.0 as f32, 3145727.0 as f32, &vm_context);
|
|
assert_eq!(result, 1.3338205 as f32);
|
|
}
|
|
|
|
// Line 396
|
|
fn c241_l396_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c241_l396_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4195835.0 as f64, 3145727.0 as f64, &vm_context);
|
|
assert_eq!(result, 1.333820449136241 as f64);
|
|
}
|
|
|
|
// Line 399
|
|
fn c242_l399_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c242_l399_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000005029633 as f32, 336324380000000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.0 as f32);
|
|
}
|
|
|
|
// Line 400
|
|
fn c243_l400_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c243_l400_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000008921987 as f32, 354097530000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.0 as f32);
|
|
}
|
|
|
|
// Line 401
|
|
fn c244_l401_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c244_l401_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-104167.47 as f32, 0.0000000000000000000000015866623 as f32, &vm_context);
|
|
assert_eq!(result, -65651950000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 402
|
|
fn c245_l402_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c245_l402_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000024938657 as f32, -0.00000000000000000000000000000000000036230088 as f32, &vm_context);
|
|
assert_eq!(result, 68834107000000.0 as f32);
|
|
}
|
|
|
|
// Line 403
|
|
fn c246_l403_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c246_l403_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-4142204200000.0 as f32, 0.0000000000000000000000011954948 as f32, &vm_context);
|
|
assert_eq!(result, -3464845000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 404
|
|
fn c247_l404_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c247_l404_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(193901163824483840000000000000000000000000000.0 as f64, 25290742357348314000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000007666883046955921 as f64);
|
|
}
|
|
|
|
// Line 405
|
|
fn c248_l405_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c248_l405_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006600332149752304 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003007915153468629 as f64, &vm_context);
|
|
assert_eq!(result, 219432125342399270000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 406
|
|
fn c249_l406_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c249_l406_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-934827517366190300000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 4809309529035847000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000019437873809582001 as f64);
|
|
}
|
|
|
|
// Line 407
|
|
fn c250_l407_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c250_l407_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-17598339088417535000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 199386072580682850000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -88262629684409150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 408
|
|
fn c251_l408_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c251_l408_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-4566268877844991000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 31282495822334530000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -145968816036246260000000000.0 as f64);
|
|
}
|
|
|
|
// Line 411
|
|
fn c252_l411_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c252_l411_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-1039406400000000000000.0 as f32, -0.000000000000000000000000012965966 as f32, &vm_context);
|
|
assert_eq!(result, f32::INFINITY);
|
|
}
|
|
|
|
// Line 412
|
|
fn c253_l412_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c253_l412_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000026831563 as f32, 31241038000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000000008588563 as f32);
|
|
}
|
|
|
|
// Line 413
|
|
fn c254_l413_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c254_l413_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.2734247 as f32, -692783700000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, -0.0000000000000000000000000018381274 as f32);
|
|
}
|
|
|
|
// Line 414
|
|
fn c255_l414_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c255_l414_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000068988827 as f32, 0.000000000000000000000000000000000000003762676 as f32, &vm_context);
|
|
assert_eq!(result, 183350460000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 415
|
|
fn c256_l415_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c256_l415_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1819916200000000000000000000.0 as f32, 205067030000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 8.874739 as f32);
|
|
}
|
|
|
|
// Line 416
|
|
fn c257_l416_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c257_l416_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021137715924428077 as f64, -16733261612910253000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -0.0 as f64);
|
|
}
|
|
|
|
// Line 417
|
|
fn c258_l417_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c258_l417_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008116644948016275 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006517571349002277 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012453480772801648 as f64);
|
|
}
|
|
|
|
// Line 418
|
|
fn c259_l418_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c259_l418_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009335476912259029 as f64, -39099281466396.5 as f64, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000023876338802497726 as f64);
|
|
}
|
|
|
|
// Line 419
|
|
fn c260_l419_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c260_l419_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-1686856985488590200000000.0 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013535993861076857 as f64, &vm_context);
|
|
assert_eq!(result, -12462010568276012000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 420
|
|
fn c261_l420_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c261_l420_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-173388773324941200000000000000000000000000000000000000000000000000000000.0 as f64, -70026160475217470.0 as f64, &vm_context);
|
|
assert_eq!(result, 2476057121342590000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 423
|
|
fn c262_l423_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c262_l423_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(93506190.0 as f32, 0.0000000000000000000000000000000000028760885 as f32, &vm_context);
|
|
assert_eq!(result, f32::INFINITY);
|
|
}
|
|
|
|
// Line 424
|
|
fn c263_l424_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c263_l424_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-200575400000000000000000.0 as f32, 246697220.0 as f32, &vm_context);
|
|
assert_eq!(result, -813042800000000.0 as f32);
|
|
}
|
|
|
|
// Line 425
|
|
fn c264_l425_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c264_l425_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(384712200000.0 as f32, -107037850000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000359417 as f32);
|
|
}
|
|
|
|
// Line 426
|
|
fn c265_l426_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c265_l426_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-4156665000000000000000000000000000.0 as f32, -901.4192 as f32, &vm_context);
|
|
assert_eq!(result, 4611245300000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 427
|
|
fn c266_l427_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c266_l427_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-6702387000000000000000000000.0 as f32, -14000.255 as f32, &vm_context);
|
|
assert_eq!(result, 478733200000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 428
|
|
fn c267_l428_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c267_l428_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010085269598907525 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000018780374032850215 as f64, &vm_context);
|
|
assert_eq!(result, -53701111496.85621 as f64);
|
|
}
|
|
|
|
// Line 429
|
|
fn c268_l429_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c268_l429_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-32571664562951100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005885738519211168 as f64, &vm_context);
|
|
assert_eq!(result, f64::INFINITY);
|
|
}
|
|
|
|
// Line 430
|
|
fn c269_l430_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c269_l430_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000031640946861233317 as f64, 0.000000000000000000045854510556516254 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006900291046010721 as f64);
|
|
}
|
|
|
|
// Line 431
|
|
fn c270_l431_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c270_l431_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-526842242946656600000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000014816907071451201 as f64, &vm_context);
|
|
assert_eq!(result, 355568298030134360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 432
|
|
fn c271_l432_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c271_l432_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4039956270017490000000000000000000000000000000000000000.0 as f64, -47097881971884274000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -0.0000000000857778757955442 as f64);
|
|
}
|
|
|
|
// Line 435
|
|
fn c272_l435_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c272_l435_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-203959560468347600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -74740887394612260000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 2728888665604071000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 436
|
|
fn c273_l436_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c273_l436_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-304261712294687660000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, -2655679232658824300000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 114570204320220420000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 437
|
|
fn c274_l437_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c274_l437_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(49235240512480730000000000000000000000000000000000000000.0 as f64, -366340828310036700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013439736089369927 as f64);
|
|
}
|
|
|
|
// Line 438
|
|
fn c275_l438_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c275_l438_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(289260843556341600000000000000000000000000000000000000000000000000.0 as f64, 517194875837335500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000000000005592879146144478 as f64);
|
|
}
|
|
|
|
// Line 439
|
|
fn c276_l439_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c276_l439_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-421542582344268600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 1428505854670649100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -295093352936560340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 442
|
|
fn c277_l442_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c277_l442_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.8622957433108482 as f64, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010359363938125513 as f64);
|
|
}
|
|
|
|
// Line 443
|
|
fn c278_l443_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c278_l443_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008566632480779937 as f64, 5381.2699796556235 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001591935084685746 as f64);
|
|
}
|
|
|
|
// Line 444
|
|
fn c279_l444_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c279_l444_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.00000000000000000000000000000000000000000008196220919495565 as f64, -10406557086484777000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007876015911295176 as f64);
|
|
}
|
|
|
|
// Line 445
|
|
fn c280_l445_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c280_l445_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007052801866447111 as f64, -13767429405781133000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005122816800851397 as f64);
|
|
}
|
|
|
|
// Line 446
|
|
fn c281_l446_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c281_l446_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022655621734165475 as f64, 133219932963494700000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017006180103974106 as f64);
|
|
}
|
|
|
|
// Line 447
|
|
fn c282_l447_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c282_l447_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004196304106554003 as f64, -9789327.297653636 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042866113053139 as f64);
|
|
}
|
|
|
|
// Line 450
|
|
fn c283_l450_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c283_l450_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1038860800000000000000000000.0 as f32, 6211079500000.0 as f32, &vm_context);
|
|
assert_eq!(result, 167259300000000.0 as f32);
|
|
}
|
|
|
|
// Line 451
|
|
fn c284_l451_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c284_l451_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1869033000000000000000000000.0 as f32, -112355730000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, -0.00001663496 as f32);
|
|
}
|
|
|
|
// Line 452
|
|
fn c285_l452_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c285_l452_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(3290747200000000000000000.0 as f32, 0.9064788 as f32, &vm_context);
|
|
assert_eq!(result, 3630252700000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 453
|
|
fn c286_l453_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c286_l453_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-908946.56 as f32, -17034289000.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.000053359818 as f32);
|
|
}
|
|
|
|
// Line 454
|
|
fn c287_l454_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c287_l454_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.00000000000024092477 as f32, -89840810000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000000000026816852 as f32);
|
|
}
|
|
|
|
// Line 455
|
|
fn c288_l455_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c288_l455_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(3910973045785834000.0 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008392730733897136 as f64, &vm_context);
|
|
assert_eq!(result, -46599529638070336000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 456
|
|
fn c289_l456_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c289_l456_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000000000000000000008379351966732404 as f64, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000021077277802048832 as f64, &vm_context);
|
|
assert_eq!(result, -3975538039318286000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 457
|
|
fn c290_l457_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c290_l457_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4561142017854715000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, 1500578067736849100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 3039589952.6465592 as f64);
|
|
}
|
|
|
|
// Line 458
|
|
fn c291_l458_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c291_l458_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-6236072401827852000000000000000000000000000000000000000.0 as f64, 83170632504609900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007497925907299316 as f64);
|
|
}
|
|
|
|
// Line 459
|
|
fn c292_l459_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c292_l459_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009757271330468098 as f64, -0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035613812243480865 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000002739743575824061 as f64);
|
|
}
|
|
|
|
// Line 462
|
|
fn c293_l462_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c293_l462_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000001046256872449641 as f64, 1.8150892711657447 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000005764217160391678 as f64);
|
|
}
|
|
|
|
// Line 463
|
|
fn c294_l463_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c294_l463_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000022038268106596436 as f64, -0.0000000000002859803943943555 as f64, &vm_context);
|
|
assert_eq!(result, -0.0000000000000000007706216418530616 as f64);
|
|
}
|
|
|
|
// Line 464
|
|
fn c295_l464_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c295_l464_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000007596539988437179 as f64, 0.00000000000000000000000000000000021055358831337124 as f64, &vm_context);
|
|
assert_eq!(result, 3607889112357986600000.0 as f64);
|
|
}
|
|
|
|
// Line 465
|
|
fn c296_l465_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c296_l465_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1120696114500866900000000000.0 as f64, 159713233802866500000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.007016927074960728 as f64);
|
|
}
|
|
|
|
// Line 466
|
|
fn c297_l466_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c297_l466_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0006342142502301953 as f64, -6391950865520085.0 as f64, &vm_context);
|
|
assert_eq!(result, -0.00000000000000000009922076429769178 as f64);
|
|
}
|
|
|
|
// Line 469
|
|
fn c298_l469_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c298_l469_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000011754944 as f32, 0.000000000000000000000000000000000000011754942 as f32, &vm_context);
|
|
assert_eq!(result, 1.0000001 as f32);
|
|
}
|
|
|
|
// Line 470
|
|
fn c299_l470_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c299_l470_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000011754942 as f32, 0.000000000000000000000000000000000000011754944 as f32, &vm_context);
|
|
assert_eq!(result, 0.9999999 as f32);
|
|
}
|
|
|
|
// Line 471
|
|
fn c300_l471_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c300_l471_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201 as f64, &vm_context);
|
|
assert_eq!(result, 1.0000000000000002 as f64);
|
|
}
|
|
|
|
// Line 472
|
|
fn c301_l472_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c301_l472_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 as f64, &vm_context);
|
|
assert_eq!(result, 0.9999999999999998 as f64);
|
|
}
|
|
|
|
// Line 475
|
|
fn c302_l475_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c302_l475_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000023841856 as f32, 340282350000000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.0 as f32);
|
|
}
|
|
|
|
// Line 476
|
|
fn c303_l476_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c303_l476_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000023841858 as f32, 340282350000000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000001 as f32);
|
|
}
|
|
|
|
// Line 477
|
|
fn c304_l477_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c304_l477_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000044408920985006257 as f64, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.0 as f64);
|
|
}
|
|
|
|
// Line 478
|
|
fn c305_l478_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c305_l478_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000004440892098500626 as f64, 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005 as f64);
|
|
}
|
|
|
|
// Line 481
|
|
fn c306_l481_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c306_l481_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f32, 0.000000000000000000000000000000000000002938736 as f32, &vm_context);
|
|
assert_eq!(result, f32::INFINITY);
|
|
}
|
|
|
|
// Line 482
|
|
fn c307_l482_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c307_l482_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f32, 0.000000000000000000000000000000000000002938737 as f32, &vm_context);
|
|
assert_eq!(result, 340282200000000000000000000000000000000.0 as f32);
|
|
}
|
|
|
|
// Line 483
|
|
fn c308_l483_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c308_l483_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f64, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005562684646268003 as f64, &vm_context);
|
|
assert_eq!(result, f64::INFINITY);
|
|
}
|
|
|
|
// Line 484
|
|
fn c309_l484_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c309_l484_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f64, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000556268464626801 as f64, &vm_context);
|
|
assert_eq!(result, 179769313486231430000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 487
|
|
fn c310_l487_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c310_l487_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f32, 85070600000000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000011754942 as f32);
|
|
}
|
|
|
|
// Line 488
|
|
fn c311_l488_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c311_l488_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f32, 85070590000000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000011754944 as f32);
|
|
}
|
|
|
|
// Line 489
|
|
fn c312_l489_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c312_l489_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f64, 44942328371557910000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002225073858507201 as f64);
|
|
}
|
|
|
|
// Line 490
|
|
fn c313_l490_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c313_l490_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f64, 44942328371557900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072014 as f64);
|
|
}
|
|
|
|
// Line 500
|
|
fn c314_l500_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c314_l500_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f32, 3.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.33333334 as f32);
|
|
}
|
|
|
|
// Line 501
|
|
fn c315_l501_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c315_l501_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(3.0 as f32, 9.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.33333334 as f32);
|
|
}
|
|
|
|
// Line 502
|
|
fn c316_l502_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c316_l502_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(9.0 as f32, 27.0 as f32, &vm_context);
|
|
assert_eq!(result, 0.33333334 as f32);
|
|
}
|
|
|
|
// Line 503
|
|
fn c317_l503_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c317_l503_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f64, 3.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.3333333333333333 as f64);
|
|
}
|
|
|
|
// Line 504
|
|
fn c318_l504_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c318_l504_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(3.0 as f64, 9.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.3333333333333333 as f64);
|
|
}
|
|
|
|
// Line 505
|
|
fn c319_l505_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c319_l505_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(9.0 as f64, 27.0 as f64, &vm_context);
|
|
assert_eq!(result, 0.3333333333333333 as f64);
|
|
}
|
|
|
|
// Line 508
|
|
fn c320_l508_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c320_l508_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000001 as f32, 0.99999994 as f32, &vm_context);
|
|
assert_eq!(result, 1.0000002 as f32);
|
|
}
|
|
|
|
// Line 509
|
|
fn c321_l509_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c321_l509_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.99999994 as f32, 1.0000001 as f32, &vm_context);
|
|
assert_eq!(result, 0.9999998 as f32);
|
|
}
|
|
|
|
// Line 510
|
|
fn c322_l510_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c322_l510_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f32, 0.99999994 as f32, &vm_context);
|
|
assert_eq!(result, 1.0000001 as f32);
|
|
}
|
|
|
|
// Line 511
|
|
fn c323_l511_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c323_l511_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f32, 1.0000001 as f32, &vm_context);
|
|
assert_eq!(result, 0.9999999 as f32);
|
|
}
|
|
|
|
// Line 512
|
|
fn c324_l512_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c324_l512_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000000000000002 as f64, 0.9999999999999999 as f64, &vm_context);
|
|
assert_eq!(result, 1.0000000000000004 as f64);
|
|
}
|
|
|
|
// Line 513
|
|
fn c325_l513_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c325_l513_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.9999999999999999 as f64, 1.0000000000000002 as f64, &vm_context);
|
|
assert_eq!(result, 0.9999999999999997 as f64);
|
|
}
|
|
|
|
// Line 514
|
|
fn c326_l514_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c326_l514_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f64, 0.9999999999999999 as f64, &vm_context);
|
|
assert_eq!(result, 1.0000000000000002 as f64);
|
|
}
|
|
|
|
// Line 515
|
|
fn c327_l515_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c327_l515_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.div") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0 as f64, 1.0000000000000002 as f64, &vm_context);
|
|
assert_eq!(result, 0.9999999999999998 as f64);
|
|
}
|
|
|
|
// Line 519
|
|
fn c328_l519_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c328_l519_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(171.0 as f32, &vm_context);
|
|
assert_eq!(result, 13.076696 as f32);
|
|
}
|
|
|
|
// Line 520
|
|
fn c329_l520_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c329_l520_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000160795 as f32, &vm_context);
|
|
assert_eq!(result, 0.00040099252 as f32);
|
|
}
|
|
|
|
// Line 521
|
|
fn c330_l521_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c330_l521_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(171.0 as f64, &vm_context);
|
|
assert_eq!(result, 13.076696830622021 as f64);
|
|
}
|
|
|
|
// Line 522
|
|
fn c331_l522_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c331_l522_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000160795 as f64, &vm_context);
|
|
assert_eq!(result, 0.00040099251863345283 as f64);
|
|
}
|
|
|
|
// Line 525
|
|
fn c332_l525_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c332_l525_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000000000000000004316357580352844 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000000000020775845543209175 as f64);
|
|
}
|
|
|
|
// Line 526
|
|
fn c333_l526_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c333_l526_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(676253300479648500000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 822346216918183800000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 527
|
|
fn c334_l527_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c334_l527_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(17485296624861996000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 4181542373916829400000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 528
|
|
fn c335_l528_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c335_l528_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000009593720960603523 as f64, &vm_context);
|
|
assert_eq!(result, 0.0000030973732355987585 as f64);
|
|
}
|
|
|
|
// Line 529
|
|
fn c336_l529_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c336_l529_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006348452898717835 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000002519613640762773 as f64);
|
|
}
|
|
|
|
// Line 533
|
|
fn c337_l533_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c337_l533_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.9999999999999999 as f64, &vm_context);
|
|
assert_eq!(result, 0.9999999999999999 as f64);
|
|
}
|
|
|
|
// Line 536
|
|
fn c338_l536_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c338_l536_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.12963942 as f32, &vm_context);
|
|
assert_eq!(result, 0.36005473 as f32);
|
|
}
|
|
|
|
// Line 537
|
|
fn c339_l537_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c339_l537_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(2345875800000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 1531625200000000.0 as f32);
|
|
}
|
|
|
|
// Line 538
|
|
fn c340_l538_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c340_l538_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.078786574 as f32, &vm_context);
|
|
assert_eq!(result, 0.28068945 as f32);
|
|
}
|
|
|
|
// Line 539
|
|
fn c341_l539_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c341_l539_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000051371026 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000000022665177 as f32);
|
|
}
|
|
|
|
// Line 540
|
|
fn c342_l540_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c342_l540_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00090167153 as f32, &vm_context);
|
|
assert_eq!(result, 0.030027846 as f32);
|
|
}
|
|
|
|
// Line 541
|
|
fn c343_l541_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c343_l541_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009591922760825561 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009793836204892116 as f64);
|
|
}
|
|
|
|
// Line 542
|
|
fn c344_l542_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c344_l542_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(935787535216400500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 30590644570136150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 543
|
|
fn c345_l543_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c345_l543_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(147706699783365580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 12153464517715332000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 544
|
|
fn c346_l544_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c346_l544_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(48800457180027890000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 6985732401117859.0 as f64);
|
|
}
|
|
|
|
// Line 545
|
|
fn c347_l545_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c347_l545_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(7618977687174540000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 2760249569726357000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 548
|
|
fn c348_l548_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c348_l548_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(154481010.0 as f32, &vm_context);
|
|
assert_eq!(result, 12429.039 as f32);
|
|
}
|
|
|
|
// Line 549
|
|
fn c349_l549_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c349_l549_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000010471305 as f32, &vm_context);
|
|
assert_eq!(result, 0.00000000000000001023294 as f32);
|
|
}
|
|
|
|
// Line 550
|
|
fn c350_l550_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c350_l550_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00003790637 as f32, &vm_context);
|
|
assert_eq!(result, 0.006156815 as f32);
|
|
}
|
|
|
|
// Line 551
|
|
fn c351_l551_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c351_l551_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000089607535 as f32, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000009466126 as f32);
|
|
}
|
|
|
|
// Line 552
|
|
fn c352_l552_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c352_l552_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000000000000000001687712 as f32, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000041081773 as f32);
|
|
}
|
|
|
|
// Line 553
|
|
fn c353_l553_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c353_l553_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(316996264378909500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 563024212959717700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 554
|
|
fn c354_l554_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c354_l554_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040573669271847993 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020142906759414837 as f64);
|
|
}
|
|
|
|
// Line 555
|
|
fn c355_l555_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c355_l555_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000015299861660588838 as f64, &vm_context);
|
|
assert_eq!(result, 0.00003911503759500793 as f64);
|
|
}
|
|
|
|
// Line 556
|
|
fn c356_l556_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c356_l556_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.0000000000000000000000000000000000000000000000000000000000000000000000002822766928951239 as f64, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000000000000000005312971794533864 as f64);
|
|
}
|
|
|
|
// Line 557
|
|
fn c357_l557_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c357_l557_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(14375957727045067000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 119899782014168260000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 560
|
|
fn c358_l560_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c358_l560_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(464023420000000000000000000000000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 681192700000000000.0 as f32);
|
|
}
|
|
|
|
// Line 561
|
|
fn c359_l561_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c359_l561_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(47536.133 as f32, &vm_context);
|
|
assert_eq!(result, 218.02783 as f32);
|
|
}
|
|
|
|
// Line 562
|
|
fn c360_l562_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c360_l562_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.812613 as f32, &vm_context);
|
|
assert_eq!(result, 0.9014505 as f32);
|
|
}
|
|
|
|
// Line 563
|
|
fn c361_l563_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c361_l563_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000009549605 as f32, &vm_context);
|
|
assert_eq!(result, 0.00000000000009772208 as f32);
|
|
}
|
|
|
|
// Line 564
|
|
fn c362_l564_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c362_l564_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000068856485 as f32, &vm_context);
|
|
assert_eq!(result, 0.000000000000008297981 as f32);
|
|
}
|
|
|
|
// Line 565
|
|
fn c363_l565_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c363_l565_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(2349768917495332200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 1532895599020146000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 566
|
|
fn c364_l566_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c364_l566_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000029262574743429683 as f64, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000000000000000000000000000000000000005409489323718985 as f64);
|
|
}
|
|
|
|
// Line 567
|
|
fn c365_l567_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c365_l567_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(377335087484490800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 19425114864126050000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 568
|
|
fn c366_l568_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c366_l568_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000035498432023945234 as f64, &vm_context);
|
|
assert_eq!(result, 0.00000018841027579180822 as f64);
|
|
}
|
|
|
|
// Line 569
|
|
fn c367_l569_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c367_l569_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000013747419336166767 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000011724938949165905 as f64);
|
|
}
|
|
|
|
// Line 572
|
|
fn c368_l572_assert_return_canonical_nan(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c368_l572_assert_return_canonical_nan");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015535152663257847 as f64, &vm_context);
|
|
assert!(result.is_quiet_nan())
|
|
}
|
|
|
|
// Line 573
|
|
fn c369_l573_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c369_l573_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(18763296348029700000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 4331662076851067.0 as f64);
|
|
}
|
|
|
|
// Line 574
|
|
fn c370_l574_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c370_l574_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000274405777036165 as f64, &vm_context);
|
|
assert_eq!(result, 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000523837548325972 as f64);
|
|
}
|
|
|
|
// Line 575
|
|
fn c371_l575_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c371_l575_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.000000000000000000000000000000000000000000000000000000000000000000000000000000000015613859952920445 as f64, &vm_context);
|
|
assert_eq!(result, 0.0000000000000000000000000000000000000000039514377070783294 as f64);
|
|
}
|
|
|
|
// Line 576
|
|
fn c372_l576_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c372_l576_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(619303768945071200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 24885814612848646000000000000000000000000000000000000000000000000000000000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 579
|
|
fn c373_l579_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c373_l579_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000001 as f32, &vm_context);
|
|
assert_eq!(result, 1.0 as f32);
|
|
}
|
|
|
|
// Line 580
|
|
fn c374_l580_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c374_l580_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000002 as f32, &vm_context);
|
|
assert_eq!(result, 1.0000001 as f32);
|
|
}
|
|
|
|
// Line 581
|
|
fn c375_l581_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c375_l581_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000000000000002 as f64, &vm_context);
|
|
assert_eq!(result, 1.0 as f64);
|
|
}
|
|
|
|
// Line 582
|
|
fn c376_l582_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c376_l582_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000000000000004 as f64, &vm_context);
|
|
assert_eq!(result, 1.0000000000000002 as f64);
|
|
}
|
|
|
|
// Line 585
|
|
fn c377_l585_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c377_l585_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.9999999 as f32, &vm_context);
|
|
assert_eq!(result, 0.99999994 as f32);
|
|
}
|
|
|
|
// Line 586
|
|
fn c378_l586_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c378_l586_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.9999998 as f32, &vm_context);
|
|
assert_eq!(result, 0.9999999 as f32);
|
|
}
|
|
|
|
// Line 587
|
|
fn c379_l587_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c379_l587_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.9999999999999998 as f64, &vm_context);
|
|
assert_eq!(result, 0.9999999999999999 as f64);
|
|
}
|
|
|
|
// Line 588
|
|
fn c380_l588_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c380_l588_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.sqrt") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.9999999999999997 as f64, &vm_context);
|
|
assert_eq!(result, 0.9999999999999998 as f64);
|
|
}
|
|
|
|
// Line 592
|
|
fn c381_l592_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c381_l592_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.abs") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f32::from_bits(2139156962), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f32::from_bits(2139156962)).is_sign_positive());
|
|
}
|
|
|
|
// Line 593
|
|
fn c382_l593_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c382_l593_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.abs") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f32::from_bits(4286640610), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f32::from_bits(2139156962)).is_sign_positive());
|
|
}
|
|
|
|
// Line 594
|
|
fn c383_l594_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c383_l594_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.abs") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f64::from_bits(9218868441285556843), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f64::from_bits(9218868441285556843)).is_sign_positive());
|
|
}
|
|
|
|
// Line 595
|
|
fn c384_l595_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c384_l595_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.abs") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f64::from_bits(18442240478140332651), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f64::from_bits(9218868441285556843)).is_sign_positive());
|
|
}
|
|
|
|
// Line 597
|
|
fn c385_l597_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c385_l597_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.neg") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f32::from_bits(2139156962), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f32::from_bits(4286640610)).is_sign_positive());
|
|
}
|
|
|
|
// Line 598
|
|
fn c386_l598_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c386_l598_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.neg") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f32::from_bits(4286640610), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f32::from_bits(2139156962)).is_sign_positive());
|
|
}
|
|
|
|
// Line 599
|
|
fn c387_l599_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c387_l599_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.neg") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f64::from_bits(9218868441285556843), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f64::from_bits(18442240478140332651)).is_sign_positive());
|
|
}
|
|
|
|
// Line 600
|
|
fn c388_l600_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c388_l600_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.neg") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f64::from_bits(18442240478140332651), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f64::from_bits(9218868441285556843)).is_sign_positive());
|
|
}
|
|
|
|
// Line 602
|
|
fn c389_l602_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c389_l602_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.copysign") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f32::from_bits(2139156962), f32::from_bits(2143289344), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f32::from_bits(2139156962)).is_sign_positive());
|
|
}
|
|
|
|
// Line 603
|
|
fn c390_l603_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c390_l603_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.copysign") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f32::from_bits(2139156962), f32::from_bits(4290772992), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f32::from_bits(4286640610)).is_sign_positive());
|
|
}
|
|
|
|
// Line 604
|
|
fn c391_l604_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c391_l604_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.copysign") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f32::from_bits(4286640610), f32::from_bits(2143289344), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f32::from_bits(2139156962)).is_sign_positive());
|
|
}
|
|
|
|
// Line 605
|
|
fn c392_l605_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c392_l605_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.copysign") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f32::from_bits(4286640610), f32::from_bits(4290772992), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f32::from_bits(4286640610)).is_sign_positive());
|
|
}
|
|
|
|
// Line 606
|
|
fn c393_l606_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c393_l606_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.copysign") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f64::from_bits(9218868441285556843), f64::from_bits(9221120237041090560), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f64::from_bits(9218868441285556843)).is_sign_positive());
|
|
}
|
|
|
|
// Line 607
|
|
fn c394_l607_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c394_l607_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.copysign") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f64::from_bits(9218868441285556843), f64::from_bits(18444492273895866368), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f64::from_bits(18442240478140332651)).is_sign_positive());
|
|
}
|
|
|
|
// Line 608
|
|
fn c395_l608_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c395_l608_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.copysign") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f64::from_bits(18442240478140332651), f64::from_bits(9221120237041090560), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f64::from_bits(9218868441285556843)).is_sign_positive());
|
|
}
|
|
|
|
// Line 609
|
|
fn c396_l609_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c396_l609_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.copysign") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(f64::from_bits(18442240478140332651), f64::from_bits(18444492273895866368), &vm_context);
|
|
assert!(result.is_nan());
|
|
assert_eq!(result.is_sign_positive(), (f64::from_bits(18442240478140332651)).is_sign_positive());
|
|
}
|
|
|
|
// Line 612
|
|
fn c397_l612_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c397_l612_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.ceil") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.99999994 as f32, &vm_context);
|
|
assert_eq!(result, 1.0 as f32);
|
|
}
|
|
|
|
// Line 613
|
|
fn c398_l613_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c398_l613_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.ceil") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000001 as f32, &vm_context);
|
|
assert_eq!(result, 2.0 as f32);
|
|
}
|
|
|
|
// Line 614
|
|
fn c399_l614_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c399_l614_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.ceil") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.9999999999999999 as f64, &vm_context);
|
|
assert_eq!(result, 1.0 as f64);
|
|
}
|
|
|
|
// Line 615
|
|
fn c400_l615_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c400_l615_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.ceil") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(1.0000000000000002 as f64, &vm_context);
|
|
assert_eq!(result, 2.0 as f64);
|
|
}
|
|
|
|
// Line 618
|
|
fn c401_l618_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c401_l618_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.ceil") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(8388607.5 as f32, &vm_context);
|
|
assert_eq!(result, 8388608.0 as f32);
|
|
}
|
|
|
|
// Line 619
|
|
fn c402_l619_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c402_l619_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.ceil") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-8388607.5 as f32, &vm_context);
|
|
assert_eq!(result, -8388607.0 as f32);
|
|
}
|
|
|
|
// Line 620
|
|
fn c403_l620_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c403_l620_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.ceil") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4503599627370495.5 as f64, &vm_context);
|
|
assert_eq!(result, 4503599627370496.0 as f64);
|
|
}
|
|
|
|
// Line 621
|
|
fn c404_l621_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c404_l621_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.ceil") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-4503599627370495.5 as f64, &vm_context);
|
|
assert_eq!(result, -4503599627370495.0 as f64);
|
|
}
|
|
|
|
// Line 625
|
|
fn c405_l625_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c405_l625_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.ceil") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(16777215.0 as f32, &vm_context);
|
|
assert_eq!(result, 16777215.0 as f32);
|
|
}
|
|
|
|
// Line 626
|
|
fn c406_l626_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c406_l626_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.ceil") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-16777215.0 as f32, &vm_context);
|
|
assert_eq!(result, -16777215.0 as f32);
|
|
}
|
|
|
|
// Line 627
|
|
fn c407_l627_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c407_l627_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.ceil") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(9007199254740991.0 as f64, &vm_context);
|
|
assert_eq!(result, 9007199254740991.0 as f64);
|
|
}
|
|
|
|
// Line 628
|
|
fn c408_l628_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c408_l628_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.ceil") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-9007199254740991.0 as f64, &vm_context);
|
|
assert_eq!(result, -9007199254740991.0 as f64);
|
|
}
|
|
|
|
// Line 631
|
|
fn c409_l631_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c409_l631_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.floor") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.99999994 as f32, &vm_context);
|
|
assert_eq!(result, -1.0 as f32);
|
|
}
|
|
|
|
// Line 632
|
|
fn c410_l632_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c410_l632_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.floor") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-1.0000001 as f32, &vm_context);
|
|
assert_eq!(result, -2.0 as f32);
|
|
}
|
|
|
|
// Line 633
|
|
fn c411_l633_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c411_l633_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.floor") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-0.9999999999999999 as f64, &vm_context);
|
|
assert_eq!(result, -1.0 as f64);
|
|
}
|
|
|
|
// Line 634
|
|
fn c412_l634_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c412_l634_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.floor") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-1.0000000000000002 as f64, &vm_context);
|
|
assert_eq!(result, -2.0 as f64);
|
|
}
|
|
|
|
// Line 637
|
|
fn c413_l637_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c413_l637_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.floor") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-8388607.5 as f32, &vm_context);
|
|
assert_eq!(result, -8388608.0 as f32);
|
|
}
|
|
|
|
// Line 638
|
|
fn c414_l638_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c414_l638_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.floor") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(8388607.5 as f32, &vm_context);
|
|
assert_eq!(result, 8388607.0 as f32);
|
|
}
|
|
|
|
// Line 639
|
|
fn c415_l639_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c415_l639_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.floor") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-4503599627370495.5 as f64, &vm_context);
|
|
assert_eq!(result, -4503599627370496.0 as f64);
|
|
}
|
|
|
|
// Line 640
|
|
fn c416_l640_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c416_l640_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.floor") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4503599627370495.5 as f64, &vm_context);
|
|
assert_eq!(result, 4503599627370495.0 as f64);
|
|
}
|
|
|
|
// Line 644
|
|
fn c417_l644_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c417_l644_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.floor") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(88607.0 as f32, &vm_context);
|
|
assert_eq!(result, 88607.0 as f32);
|
|
}
|
|
|
|
// Line 645
|
|
fn c418_l645_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c418_l645_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.floor") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(88607.0 as f64, &vm_context);
|
|
assert_eq!(result, 88607.0 as f64);
|
|
}
|
|
|
|
// Line 648
|
|
fn c419_l648_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c419_l648_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.trunc") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-8388607.5 as f32, &vm_context);
|
|
assert_eq!(result, -8388607.0 as f32);
|
|
}
|
|
|
|
// Line 649
|
|
fn c420_l649_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c420_l649_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.trunc") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(8388607.5 as f32, &vm_context);
|
|
assert_eq!(result, 8388607.0 as f32);
|
|
}
|
|
|
|
// Line 650
|
|
fn c421_l650_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c421_l650_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.trunc") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-4503599627370495.5 as f64, &vm_context);
|
|
assert_eq!(result, -4503599627370495.0 as f64);
|
|
}
|
|
|
|
// Line 651
|
|
fn c422_l651_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c422_l651_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.trunc") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4503599627370495.5 as f64, &vm_context);
|
|
assert_eq!(result, 4503599627370495.0 as f64);
|
|
}
|
|
|
|
// Line 656
|
|
fn c423_l656_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c423_l656_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(8388609.0 as f32, &vm_context);
|
|
assert_eq!(result, 8388609.0 as f32);
|
|
}
|
|
|
|
// Line 657
|
|
fn c424_l657_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c424_l657_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(8388610.0 as f32, &vm_context);
|
|
assert_eq!(result, 8388610.0 as f32);
|
|
}
|
|
|
|
// Line 658
|
|
fn c425_l658_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c425_l658_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.49999997 as f32, &vm_context);
|
|
assert_eq!(result, 0.0 as f32);
|
|
}
|
|
|
|
// Line 659
|
|
fn c426_l659_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c426_l659_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(281474960000000.0 as f32, &vm_context);
|
|
assert_eq!(result, 281474960000000.0 as f32);
|
|
}
|
|
|
|
// Line 660
|
|
fn c427_l660_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c427_l660_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4503599627370497.0 as f64, &vm_context);
|
|
assert_eq!(result, 4503599627370497.0 as f64);
|
|
}
|
|
|
|
// Line 661
|
|
fn c428_l661_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c428_l661_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4503599627370498.0 as f64, &vm_context);
|
|
assert_eq!(result, 4503599627370498.0 as f64);
|
|
}
|
|
|
|
// Line 662
|
|
fn c429_l662_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c429_l662_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(0.49999999999999994 as f64, &vm_context);
|
|
assert_eq!(result, 0.0 as f64);
|
|
}
|
|
|
|
// Line 663
|
|
fn c430_l663_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c430_l663_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(81129638414606670000000000000000.0 as f64, &vm_context);
|
|
assert_eq!(result, 81129638414606670000000000000000.0 as f64);
|
|
}
|
|
|
|
// Line 667
|
|
fn c431_l667_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c431_l667_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4.5 as f32, &vm_context);
|
|
assert_eq!(result, 4.0 as f32);
|
|
}
|
|
|
|
// Line 668
|
|
fn c432_l668_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c432_l668_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-4.5 as f32, &vm_context);
|
|
assert_eq!(result, -4.0 as f32);
|
|
}
|
|
|
|
// Line 669
|
|
fn c433_l669_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c433_l669_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-3.5 as f32, &vm_context);
|
|
assert_eq!(result, -4.0 as f32);
|
|
}
|
|
|
|
// Line 670
|
|
fn c434_l670_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c434_l670_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4.5 as f64, &vm_context);
|
|
assert_eq!(result, 4.0 as f64);
|
|
}
|
|
|
|
// Line 671
|
|
fn c435_l671_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c435_l671_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-4.5 as f64, &vm_context);
|
|
assert_eq!(result, -4.0 as f64);
|
|
}
|
|
|
|
// Line 672
|
|
fn c436_l672_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c436_l672_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-3.5 as f64, &vm_context);
|
|
assert_eq!(result, -4.0 as f64);
|
|
}
|
|
|
|
// Line 675
|
|
fn c437_l675_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c437_l675_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-8388607.5 as f32, &vm_context);
|
|
assert_eq!(result, -8388608.0 as f32);
|
|
}
|
|
|
|
// Line 676
|
|
fn c438_l676_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c438_l676_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f32.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f32, &VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(8388607.5 as f32, &vm_context);
|
|
assert_eq!(result, 8388608.0 as f32);
|
|
}
|
|
|
|
// Line 677
|
|
fn c439_l677_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c439_l677_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(-4503599627370495.5 as f64, &vm_context);
|
|
assert_eq!(result, -4503599627370496.0 as f64);
|
|
}
|
|
|
|
// Line 678
|
|
fn c440_l678_action_invoke(result_object: &ResultObject, vm_context: &VmCtx) {
|
|
println!("Executing function {}", "c440_l678_action_invoke");
|
|
let func_index = match result_object.module.info.exports.get("f64.nearest") {
|
|
Some(&Export::Function(index)) => index,
|
|
_ => panic!("Function not found"),
|
|
};
|
|
let invoke_fn: fn(f64, &VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index);
|
|
let result = invoke_fn(4503599627370495.5 as f64, &vm_context);
|
|
assert_eq!(result, 4503599627370496.0 as f64);
|
|
}
|
|
|
|
#[test]
|
|
fn test_module_1() {
|
|
let result_object = create_module_1();
|
|
let vm_context = result_object.instance.generate_context();
|
|
// We group the calls together
|
|
start_module_1(&result_object, &vm_context);
|
|
c1_l50_action_invoke(&result_object, &vm_context);
|
|
c2_l51_action_invoke(&result_object, &vm_context);
|
|
c3_l55_action_invoke(&result_object, &vm_context);
|
|
c4_l56_action_invoke(&result_object, &vm_context);
|
|
c5_l57_action_invoke(&result_object, &vm_context);
|
|
c6_l58_action_invoke(&result_object, &vm_context);
|
|
c7_l61_action_invoke(&result_object, &vm_context);
|
|
c8_l62_action_invoke(&result_object, &vm_context);
|
|
c9_l67_action_invoke(&result_object, &vm_context);
|
|
c10_l68_action_invoke(&result_object, &vm_context);
|
|
c11_l72_action_invoke(&result_object, &vm_context);
|
|
c12_l75_action_invoke(&result_object, &vm_context);
|
|
c13_l78_action_invoke(&result_object, &vm_context);
|
|
c14_l81_action_invoke(&result_object, &vm_context);
|
|
c15_l82_action_invoke(&result_object, &vm_context);
|
|
c16_l83_action_invoke(&result_object, &vm_context);
|
|
c17_l84_action_invoke(&result_object, &vm_context);
|
|
c18_l87_action_invoke(&result_object, &vm_context);
|
|
c19_l88_action_invoke(&result_object, &vm_context);
|
|
c20_l89_action_invoke(&result_object, &vm_context);
|
|
c21_l90_action_invoke(&result_object, &vm_context);
|
|
c22_l91_action_invoke(&result_object, &vm_context);
|
|
c23_l92_action_invoke(&result_object, &vm_context);
|
|
c24_l93_action_invoke(&result_object, &vm_context);
|
|
c25_l94_action_invoke(&result_object, &vm_context);
|
|
c26_l95_action_invoke(&result_object, &vm_context);
|
|
c27_l96_action_invoke(&result_object, &vm_context);
|
|
c28_l99_action_invoke(&result_object, &vm_context);
|
|
c29_l100_action_invoke(&result_object, &vm_context);
|
|
c30_l101_action_invoke(&result_object, &vm_context);
|
|
c31_l102_action_invoke(&result_object, &vm_context);
|
|
c32_l103_action_invoke(&result_object, &vm_context);
|
|
c33_l104_action_invoke(&result_object, &vm_context);
|
|
c34_l105_action_invoke(&result_object, &vm_context);
|
|
c35_l106_action_invoke(&result_object, &vm_context);
|
|
c36_l107_action_invoke(&result_object, &vm_context);
|
|
c37_l108_action_invoke(&result_object, &vm_context);
|
|
c38_l111_action_invoke(&result_object, &vm_context);
|
|
c39_l112_action_invoke(&result_object, &vm_context);
|
|
c40_l113_action_invoke(&result_object, &vm_context);
|
|
c41_l114_action_invoke(&result_object, &vm_context);
|
|
c42_l115_action_invoke(&result_object, &vm_context);
|
|
c43_l116_action_invoke(&result_object, &vm_context);
|
|
c44_l117_action_invoke(&result_object, &vm_context);
|
|
c45_l118_action_invoke(&result_object, &vm_context);
|
|
c46_l119_action_invoke(&result_object, &vm_context);
|
|
c47_l120_action_invoke(&result_object, &vm_context);
|
|
c48_l123_action_invoke(&result_object, &vm_context);
|
|
c49_l124_action_invoke(&result_object, &vm_context);
|
|
c50_l125_action_invoke(&result_object, &vm_context);
|
|
c51_l126_action_invoke(&result_object, &vm_context);
|
|
c52_l127_action_invoke(&result_object, &vm_context);
|
|
c53_l130_action_invoke(&result_object, &vm_context);
|
|
c54_l131_action_invoke(&result_object, &vm_context);
|
|
c55_l132_action_invoke(&result_object, &vm_context);
|
|
c56_l133_action_invoke(&result_object, &vm_context);
|
|
c57_l134_action_invoke(&result_object, &vm_context);
|
|
c58_l137_action_invoke(&result_object, &vm_context);
|
|
c59_l138_action_invoke(&result_object, &vm_context);
|
|
c60_l139_action_invoke(&result_object, &vm_context);
|
|
c61_l140_action_invoke(&result_object, &vm_context);
|
|
c62_l141_action_invoke(&result_object, &vm_context);
|
|
c63_l142_action_invoke(&result_object, &vm_context);
|
|
c64_l143_action_invoke(&result_object, &vm_context);
|
|
c65_l144_action_invoke(&result_object, &vm_context);
|
|
c66_l145_action_invoke(&result_object, &vm_context);
|
|
c67_l146_action_invoke(&result_object, &vm_context);
|
|
c68_l149_action_invoke(&result_object, &vm_context);
|
|
c69_l150_action_invoke(&result_object, &vm_context);
|
|
c70_l151_action_invoke(&result_object, &vm_context);
|
|
c71_l152_action_invoke(&result_object, &vm_context);
|
|
c72_l153_action_invoke(&result_object, &vm_context);
|
|
c73_l154_action_invoke(&result_object, &vm_context);
|
|
c74_l155_action_invoke(&result_object, &vm_context);
|
|
c75_l156_action_invoke(&result_object, &vm_context);
|
|
c76_l157_action_invoke(&result_object, &vm_context);
|
|
c77_l158_action_invoke(&result_object, &vm_context);
|
|
c78_l162_action_invoke(&result_object, &vm_context);
|
|
c79_l163_action_invoke(&result_object, &vm_context);
|
|
c80_l166_action_invoke(&result_object, &vm_context);
|
|
c81_l167_action_invoke(&result_object, &vm_context);
|
|
c82_l170_action_invoke(&result_object, &vm_context);
|
|
c83_l171_action_invoke(&result_object, &vm_context);
|
|
c84_l172_action_invoke(&result_object, &vm_context);
|
|
c85_l173_action_invoke(&result_object, &vm_context);
|
|
c86_l177_action_invoke(&result_object, &vm_context);
|
|
c87_l178_action_invoke(&result_object, &vm_context);
|
|
c88_l182_action_invoke(&result_object, &vm_context);
|
|
c89_l183_action_invoke(&result_object, &vm_context);
|
|
c90_l184_action_invoke(&result_object, &vm_context);
|
|
c91_l185_action_invoke(&result_object, &vm_context);
|
|
c92_l188_action_invoke(&result_object, &vm_context);
|
|
c93_l189_action_invoke(&result_object, &vm_context);
|
|
c94_l190_action_invoke(&result_object, &vm_context);
|
|
c95_l191_action_invoke(&result_object, &vm_context);
|
|
c96_l192_action_invoke(&result_object, &vm_context);
|
|
c97_l193_action_invoke(&result_object, &vm_context);
|
|
c98_l194_action_invoke(&result_object, &vm_context);
|
|
c99_l195_action_invoke(&result_object, &vm_context);
|
|
c100_l196_action_invoke(&result_object, &vm_context);
|
|
c101_l197_action_invoke(&result_object, &vm_context);
|
|
c102_l200_action_invoke(&result_object, &vm_context);
|
|
c103_l201_action_invoke(&result_object, &vm_context);
|
|
c104_l202_action_invoke(&result_object, &vm_context);
|
|
c105_l203_action_invoke(&result_object, &vm_context);
|
|
c106_l204_action_invoke(&result_object, &vm_context);
|
|
c107_l205_action_invoke(&result_object, &vm_context);
|
|
c108_l206_action_invoke(&result_object, &vm_context);
|
|
c109_l207_action_invoke(&result_object, &vm_context);
|
|
c110_l208_action_invoke(&result_object, &vm_context);
|
|
c111_l209_action_invoke(&result_object, &vm_context);
|
|
c112_l212_action_invoke(&result_object, &vm_context);
|
|
c113_l213_action_invoke(&result_object, &vm_context);
|
|
c114_l214_action_invoke(&result_object, &vm_context);
|
|
c115_l215_action_invoke(&result_object, &vm_context);
|
|
c116_l216_action_invoke(&result_object, &vm_context);
|
|
c117_l217_action_invoke(&result_object, &vm_context);
|
|
c118_l218_action_invoke(&result_object, &vm_context);
|
|
c119_l219_action_invoke(&result_object, &vm_context);
|
|
c120_l220_action_invoke(&result_object, &vm_context);
|
|
c121_l221_action_invoke(&result_object, &vm_context);
|
|
c122_l224_action_invoke(&result_object, &vm_context);
|
|
c123_l225_action_invoke(&result_object, &vm_context);
|
|
c124_l226_action_invoke(&result_object, &vm_context);
|
|
c125_l227_action_invoke(&result_object, &vm_context);
|
|
c126_l228_action_invoke(&result_object, &vm_context);
|
|
c127_l231_action_invoke(&result_object, &vm_context);
|
|
c128_l232_action_invoke(&result_object, &vm_context);
|
|
c129_l233_action_invoke(&result_object, &vm_context);
|
|
c130_l234_action_invoke(&result_object, &vm_context);
|
|
c131_l235_action_invoke(&result_object, &vm_context);
|
|
c132_l239_action_invoke(&result_object, &vm_context);
|
|
c133_l240_action_invoke(&result_object, &vm_context);
|
|
c134_l243_action_invoke(&result_object, &vm_context);
|
|
c135_l244_action_invoke(&result_object, &vm_context);
|
|
c136_l245_action_invoke(&result_object, &vm_context);
|
|
c137_l246_action_invoke(&result_object, &vm_context);
|
|
c138_l247_action_invoke(&result_object, &vm_context);
|
|
c139_l248_action_invoke(&result_object, &vm_context);
|
|
c140_l249_action_invoke(&result_object, &vm_context);
|
|
c141_l250_action_invoke(&result_object, &vm_context);
|
|
c142_l251_action_invoke(&result_object, &vm_context);
|
|
c143_l252_action_invoke(&result_object, &vm_context);
|
|
c144_l255_action_invoke(&result_object, &vm_context);
|
|
c145_l256_action_invoke(&result_object, &vm_context);
|
|
c146_l259_action_invoke(&result_object, &vm_context);
|
|
c147_l260_action_invoke(&result_object, &vm_context);
|
|
c148_l261_action_invoke(&result_object, &vm_context);
|
|
c149_l262_action_invoke(&result_object, &vm_context);
|
|
c150_l263_action_invoke(&result_object, &vm_context);
|
|
c151_l264_action_invoke(&result_object, &vm_context);
|
|
c152_l268_action_invoke(&result_object, &vm_context);
|
|
c153_l269_action_invoke(&result_object, &vm_context);
|
|
c154_l270_action_invoke(&result_object, &vm_context);
|
|
c155_l271_action_invoke(&result_object, &vm_context);
|
|
c156_l274_action_invoke(&result_object, &vm_context);
|
|
c157_l275_action_invoke(&result_object, &vm_context);
|
|
c158_l276_action_invoke(&result_object, &vm_context);
|
|
c159_l277_action_invoke(&result_object, &vm_context);
|
|
c160_l278_action_invoke(&result_object, &vm_context);
|
|
c161_l279_action_invoke(&result_object, &vm_context);
|
|
c162_l284_action_invoke(&result_object, &vm_context);
|
|
c163_l285_action_invoke(&result_object, &vm_context);
|
|
c164_l289_action_invoke(&result_object, &vm_context);
|
|
c165_l290_action_invoke(&result_object, &vm_context);
|
|
c166_l293_action_invoke(&result_object, &vm_context);
|
|
c167_l294_action_invoke(&result_object, &vm_context);
|
|
c168_l295_action_invoke(&result_object, &vm_context);
|
|
c169_l296_action_invoke(&result_object, &vm_context);
|
|
c170_l297_action_invoke(&result_object, &vm_context);
|
|
c171_l298_action_invoke(&result_object, &vm_context);
|
|
c172_l299_action_invoke(&result_object, &vm_context);
|
|
c173_l300_action_invoke(&result_object, &vm_context);
|
|
c174_l301_action_invoke(&result_object, &vm_context);
|
|
c175_l302_action_invoke(&result_object, &vm_context);
|
|
c176_l305_action_invoke(&result_object, &vm_context);
|
|
c177_l306_action_invoke(&result_object, &vm_context);
|
|
c178_l307_action_invoke(&result_object, &vm_context);
|
|
c179_l308_action_invoke(&result_object, &vm_context);
|
|
c180_l309_action_invoke(&result_object, &vm_context);
|
|
c181_l310_action_invoke(&result_object, &vm_context);
|
|
c182_l311_action_invoke(&result_object, &vm_context);
|
|
c183_l312_action_invoke(&result_object, &vm_context);
|
|
c184_l313_action_invoke(&result_object, &vm_context);
|
|
c185_l314_action_invoke(&result_object, &vm_context);
|
|
c186_l317_action_invoke(&result_object, &vm_context);
|
|
c187_l318_action_invoke(&result_object, &vm_context);
|
|
c188_l319_action_invoke(&result_object, &vm_context);
|
|
c189_l320_action_invoke(&result_object, &vm_context);
|
|
c190_l321_action_invoke(&result_object, &vm_context);
|
|
c191_l322_action_invoke(&result_object, &vm_context);
|
|
c192_l323_action_invoke(&result_object, &vm_context);
|
|
c193_l324_action_invoke(&result_object, &vm_context);
|
|
c194_l325_action_invoke(&result_object, &vm_context);
|
|
c195_l326_action_invoke(&result_object, &vm_context);
|
|
c196_l329_action_invoke(&result_object, &vm_context);
|
|
c197_l330_action_invoke(&result_object, &vm_context);
|
|
c198_l331_action_invoke(&result_object, &vm_context);
|
|
c199_l332_action_invoke(&result_object, &vm_context);
|
|
c200_l333_action_invoke(&result_object, &vm_context);
|
|
c201_l336_action_invoke(&result_object, &vm_context);
|
|
c202_l337_action_invoke(&result_object, &vm_context);
|
|
c203_l338_action_invoke(&result_object, &vm_context);
|
|
c204_l339_action_invoke(&result_object, &vm_context);
|
|
c205_l340_action_invoke(&result_object, &vm_context);
|
|
c206_l343_action_invoke(&result_object, &vm_context);
|
|
c207_l344_action_invoke(&result_object, &vm_context);
|
|
c208_l345_action_invoke(&result_object, &vm_context);
|
|
c209_l346_action_invoke(&result_object, &vm_context);
|
|
c210_l347_action_invoke(&result_object, &vm_context);
|
|
c211_l350_action_invoke(&result_object, &vm_context);
|
|
c212_l351_action_invoke(&result_object, &vm_context);
|
|
c213_l352_action_invoke(&result_object, &vm_context);
|
|
c214_l353_action_invoke(&result_object, &vm_context);
|
|
c215_l356_action_invoke(&result_object, &vm_context);
|
|
c216_l357_action_invoke(&result_object, &vm_context);
|
|
c217_l358_action_invoke(&result_object, &vm_context);
|
|
c218_l359_action_invoke(&result_object, &vm_context);
|
|
c219_l362_action_invoke(&result_object, &vm_context);
|
|
c220_l363_action_invoke(&result_object, &vm_context);
|
|
c221_l364_action_invoke(&result_object, &vm_context);
|
|
c222_l365_action_invoke(&result_object, &vm_context);
|
|
c223_l368_action_invoke(&result_object, &vm_context);
|
|
c224_l369_action_invoke(&result_object, &vm_context);
|
|
c225_l370_action_invoke(&result_object, &vm_context);
|
|
c226_l371_action_invoke(&result_object, &vm_context);
|
|
c227_l375_action_invoke(&result_object, &vm_context);
|
|
c228_l376_action_invoke(&result_object, &vm_context);
|
|
c229_l379_action_invoke(&result_object, &vm_context);
|
|
c230_l382_action_invoke(&result_object, &vm_context);
|
|
c231_l383_action_invoke(&result_object, &vm_context);
|
|
c232_l384_action_invoke(&result_object, &vm_context);
|
|
c233_l385_action_invoke(&result_object, &vm_context);
|
|
c234_l386_action_invoke(&result_object, &vm_context);
|
|
c235_l387_action_invoke(&result_object, &vm_context);
|
|
c236_l388_action_invoke(&result_object, &vm_context);
|
|
c237_l389_action_invoke(&result_object, &vm_context);
|
|
c238_l390_action_invoke(&result_object, &vm_context);
|
|
c239_l391_action_invoke(&result_object, &vm_context);
|
|
c240_l395_action_invoke(&result_object, &vm_context);
|
|
c241_l396_action_invoke(&result_object, &vm_context);
|
|
c242_l399_action_invoke(&result_object, &vm_context);
|
|
c243_l400_action_invoke(&result_object, &vm_context);
|
|
c244_l401_action_invoke(&result_object, &vm_context);
|
|
c245_l402_action_invoke(&result_object, &vm_context);
|
|
c246_l403_action_invoke(&result_object, &vm_context);
|
|
c247_l404_action_invoke(&result_object, &vm_context);
|
|
c248_l405_action_invoke(&result_object, &vm_context);
|
|
c249_l406_action_invoke(&result_object, &vm_context);
|
|
c250_l407_action_invoke(&result_object, &vm_context);
|
|
c251_l408_action_invoke(&result_object, &vm_context);
|
|
c252_l411_action_invoke(&result_object, &vm_context);
|
|
c253_l412_action_invoke(&result_object, &vm_context);
|
|
c254_l413_action_invoke(&result_object, &vm_context);
|
|
c255_l414_action_invoke(&result_object, &vm_context);
|
|
c256_l415_action_invoke(&result_object, &vm_context);
|
|
c257_l416_action_invoke(&result_object, &vm_context);
|
|
c258_l417_action_invoke(&result_object, &vm_context);
|
|
c259_l418_action_invoke(&result_object, &vm_context);
|
|
c260_l419_action_invoke(&result_object, &vm_context);
|
|
c261_l420_action_invoke(&result_object, &vm_context);
|
|
c262_l423_action_invoke(&result_object, &vm_context);
|
|
c263_l424_action_invoke(&result_object, &vm_context);
|
|
c264_l425_action_invoke(&result_object, &vm_context);
|
|
c265_l426_action_invoke(&result_object, &vm_context);
|
|
c266_l427_action_invoke(&result_object, &vm_context);
|
|
c267_l428_action_invoke(&result_object, &vm_context);
|
|
c268_l429_action_invoke(&result_object, &vm_context);
|
|
c269_l430_action_invoke(&result_object, &vm_context);
|
|
c270_l431_action_invoke(&result_object, &vm_context);
|
|
c271_l432_action_invoke(&result_object, &vm_context);
|
|
c272_l435_action_invoke(&result_object, &vm_context);
|
|
c273_l436_action_invoke(&result_object, &vm_context);
|
|
c274_l437_action_invoke(&result_object, &vm_context);
|
|
c275_l438_action_invoke(&result_object, &vm_context);
|
|
c276_l439_action_invoke(&result_object, &vm_context);
|
|
c277_l442_action_invoke(&result_object, &vm_context);
|
|
c278_l443_action_invoke(&result_object, &vm_context);
|
|
c279_l444_action_invoke(&result_object, &vm_context);
|
|
c280_l445_action_invoke(&result_object, &vm_context);
|
|
c281_l446_action_invoke(&result_object, &vm_context);
|
|
c282_l447_action_invoke(&result_object, &vm_context);
|
|
c283_l450_action_invoke(&result_object, &vm_context);
|
|
c284_l451_action_invoke(&result_object, &vm_context);
|
|
c285_l452_action_invoke(&result_object, &vm_context);
|
|
c286_l453_action_invoke(&result_object, &vm_context);
|
|
c287_l454_action_invoke(&result_object, &vm_context);
|
|
c288_l455_action_invoke(&result_object, &vm_context);
|
|
c289_l456_action_invoke(&result_object, &vm_context);
|
|
c290_l457_action_invoke(&result_object, &vm_context);
|
|
c291_l458_action_invoke(&result_object, &vm_context);
|
|
c292_l459_action_invoke(&result_object, &vm_context);
|
|
c293_l462_action_invoke(&result_object, &vm_context);
|
|
c294_l463_action_invoke(&result_object, &vm_context);
|
|
c295_l464_action_invoke(&result_object, &vm_context);
|
|
c296_l465_action_invoke(&result_object, &vm_context);
|
|
c297_l466_action_invoke(&result_object, &vm_context);
|
|
c298_l469_action_invoke(&result_object, &vm_context);
|
|
c299_l470_action_invoke(&result_object, &vm_context);
|
|
c300_l471_action_invoke(&result_object, &vm_context);
|
|
c301_l472_action_invoke(&result_object, &vm_context);
|
|
c302_l475_action_invoke(&result_object, &vm_context);
|
|
c303_l476_action_invoke(&result_object, &vm_context);
|
|
c304_l477_action_invoke(&result_object, &vm_context);
|
|
c305_l478_action_invoke(&result_object, &vm_context);
|
|
c306_l481_action_invoke(&result_object, &vm_context);
|
|
c307_l482_action_invoke(&result_object, &vm_context);
|
|
c308_l483_action_invoke(&result_object, &vm_context);
|
|
c309_l484_action_invoke(&result_object, &vm_context);
|
|
c310_l487_action_invoke(&result_object, &vm_context);
|
|
c311_l488_action_invoke(&result_object, &vm_context);
|
|
c312_l489_action_invoke(&result_object, &vm_context);
|
|
c313_l490_action_invoke(&result_object, &vm_context);
|
|
c314_l500_action_invoke(&result_object, &vm_context);
|
|
c315_l501_action_invoke(&result_object, &vm_context);
|
|
c316_l502_action_invoke(&result_object, &vm_context);
|
|
c317_l503_action_invoke(&result_object, &vm_context);
|
|
c318_l504_action_invoke(&result_object, &vm_context);
|
|
c319_l505_action_invoke(&result_object, &vm_context);
|
|
c320_l508_action_invoke(&result_object, &vm_context);
|
|
c321_l509_action_invoke(&result_object, &vm_context);
|
|
c322_l510_action_invoke(&result_object, &vm_context);
|
|
c323_l511_action_invoke(&result_object, &vm_context);
|
|
c324_l512_action_invoke(&result_object, &vm_context);
|
|
c325_l513_action_invoke(&result_object, &vm_context);
|
|
c326_l514_action_invoke(&result_object, &vm_context);
|
|
c327_l515_action_invoke(&result_object, &vm_context);
|
|
c328_l519_action_invoke(&result_object, &vm_context);
|
|
c329_l520_action_invoke(&result_object, &vm_context);
|
|
c330_l521_action_invoke(&result_object, &vm_context);
|
|
c331_l522_action_invoke(&result_object, &vm_context);
|
|
c332_l525_action_invoke(&result_object, &vm_context);
|
|
c333_l526_action_invoke(&result_object, &vm_context);
|
|
c334_l527_action_invoke(&result_object, &vm_context);
|
|
c335_l528_action_invoke(&result_object, &vm_context);
|
|
c336_l529_action_invoke(&result_object, &vm_context);
|
|
c337_l533_action_invoke(&result_object, &vm_context);
|
|
c338_l536_action_invoke(&result_object, &vm_context);
|
|
c339_l537_action_invoke(&result_object, &vm_context);
|
|
c340_l538_action_invoke(&result_object, &vm_context);
|
|
c341_l539_action_invoke(&result_object, &vm_context);
|
|
c342_l540_action_invoke(&result_object, &vm_context);
|
|
c343_l541_action_invoke(&result_object, &vm_context);
|
|
c344_l542_action_invoke(&result_object, &vm_context);
|
|
c345_l543_action_invoke(&result_object, &vm_context);
|
|
c346_l544_action_invoke(&result_object, &vm_context);
|
|
c347_l545_action_invoke(&result_object, &vm_context);
|
|
c348_l548_action_invoke(&result_object, &vm_context);
|
|
c349_l549_action_invoke(&result_object, &vm_context);
|
|
c350_l550_action_invoke(&result_object, &vm_context);
|
|
c351_l551_action_invoke(&result_object, &vm_context);
|
|
c352_l552_action_invoke(&result_object, &vm_context);
|
|
c353_l553_action_invoke(&result_object, &vm_context);
|
|
c354_l554_action_invoke(&result_object, &vm_context);
|
|
c355_l555_action_invoke(&result_object, &vm_context);
|
|
c356_l556_action_invoke(&result_object, &vm_context);
|
|
c357_l557_action_invoke(&result_object, &vm_context);
|
|
c358_l560_action_invoke(&result_object, &vm_context);
|
|
c359_l561_action_invoke(&result_object, &vm_context);
|
|
c360_l562_action_invoke(&result_object, &vm_context);
|
|
c361_l563_action_invoke(&result_object, &vm_context);
|
|
c362_l564_action_invoke(&result_object, &vm_context);
|
|
c363_l565_action_invoke(&result_object, &vm_context);
|
|
c364_l566_action_invoke(&result_object, &vm_context);
|
|
c365_l567_action_invoke(&result_object, &vm_context);
|
|
c366_l568_action_invoke(&result_object, &vm_context);
|
|
c367_l569_action_invoke(&result_object, &vm_context);
|
|
c368_l572_assert_return_canonical_nan(&result_object, &vm_context);
|
|
c369_l573_action_invoke(&result_object, &vm_context);
|
|
c370_l574_action_invoke(&result_object, &vm_context);
|
|
c371_l575_action_invoke(&result_object, &vm_context);
|
|
c372_l576_action_invoke(&result_object, &vm_context);
|
|
c373_l579_action_invoke(&result_object, &vm_context);
|
|
c374_l580_action_invoke(&result_object, &vm_context);
|
|
c375_l581_action_invoke(&result_object, &vm_context);
|
|
c376_l582_action_invoke(&result_object, &vm_context);
|
|
c377_l585_action_invoke(&result_object, &vm_context);
|
|
c378_l586_action_invoke(&result_object, &vm_context);
|
|
c379_l587_action_invoke(&result_object, &vm_context);
|
|
c380_l588_action_invoke(&result_object, &vm_context);
|
|
c381_l592_action_invoke(&result_object, &vm_context);
|
|
c382_l593_action_invoke(&result_object, &vm_context);
|
|
c383_l594_action_invoke(&result_object, &vm_context);
|
|
c384_l595_action_invoke(&result_object, &vm_context);
|
|
c385_l597_action_invoke(&result_object, &vm_context);
|
|
c386_l598_action_invoke(&result_object, &vm_context);
|
|
c387_l599_action_invoke(&result_object, &vm_context);
|
|
c388_l600_action_invoke(&result_object, &vm_context);
|
|
c389_l602_action_invoke(&result_object, &vm_context);
|
|
c390_l603_action_invoke(&result_object, &vm_context);
|
|
c391_l604_action_invoke(&result_object, &vm_context);
|
|
c392_l605_action_invoke(&result_object, &vm_context);
|
|
c393_l606_action_invoke(&result_object, &vm_context);
|
|
c394_l607_action_invoke(&result_object, &vm_context);
|
|
c395_l608_action_invoke(&result_object, &vm_context);
|
|
c396_l609_action_invoke(&result_object, &vm_context);
|
|
c397_l612_action_invoke(&result_object, &vm_context);
|
|
c398_l613_action_invoke(&result_object, &vm_context);
|
|
c399_l614_action_invoke(&result_object, &vm_context);
|
|
c400_l615_action_invoke(&result_object, &vm_context);
|
|
c401_l618_action_invoke(&result_object, &vm_context);
|
|
c402_l619_action_invoke(&result_object, &vm_context);
|
|
c403_l620_action_invoke(&result_object, &vm_context);
|
|
c404_l621_action_invoke(&result_object, &vm_context);
|
|
c405_l625_action_invoke(&result_object, &vm_context);
|
|
c406_l626_action_invoke(&result_object, &vm_context);
|
|
c407_l627_action_invoke(&result_object, &vm_context);
|
|
c408_l628_action_invoke(&result_object, &vm_context);
|
|
c409_l631_action_invoke(&result_object, &vm_context);
|
|
c410_l632_action_invoke(&result_object, &vm_context);
|
|
c411_l633_action_invoke(&result_object, &vm_context);
|
|
c412_l634_action_invoke(&result_object, &vm_context);
|
|
c413_l637_action_invoke(&result_object, &vm_context);
|
|
c414_l638_action_invoke(&result_object, &vm_context);
|
|
c415_l639_action_invoke(&result_object, &vm_context);
|
|
c416_l640_action_invoke(&result_object, &vm_context);
|
|
c417_l644_action_invoke(&result_object, &vm_context);
|
|
c418_l645_action_invoke(&result_object, &vm_context);
|
|
c419_l648_action_invoke(&result_object, &vm_context);
|
|
c420_l649_action_invoke(&result_object, &vm_context);
|
|
c421_l650_action_invoke(&result_object, &vm_context);
|
|
c422_l651_action_invoke(&result_object, &vm_context);
|
|
c423_l656_action_invoke(&result_object, &vm_context);
|
|
c424_l657_action_invoke(&result_object, &vm_context);
|
|
c425_l658_action_invoke(&result_object, &vm_context);
|
|
c426_l659_action_invoke(&result_object, &vm_context);
|
|
c427_l660_action_invoke(&result_object, &vm_context);
|
|
c428_l661_action_invoke(&result_object, &vm_context);
|
|
c429_l662_action_invoke(&result_object, &vm_context);
|
|
c430_l663_action_invoke(&result_object, &vm_context);
|
|
c431_l667_action_invoke(&result_object, &vm_context);
|
|
c432_l668_action_invoke(&result_object, &vm_context);
|
|
c433_l669_action_invoke(&result_object, &vm_context);
|
|
c434_l670_action_invoke(&result_object, &vm_context);
|
|
c435_l671_action_invoke(&result_object, &vm_context);
|
|
c436_l672_action_invoke(&result_object, &vm_context);
|
|
c437_l675_action_invoke(&result_object, &vm_context);
|
|
c438_l676_action_invoke(&result_object, &vm_context);
|
|
c439_l677_action_invoke(&result_object, &vm_context);
|
|
c440_l678_action_invoke(&result_object, &vm_context);
|
|
}
|