mirror of
https://github.com/fluencelabs/wasmer
synced 2024-12-15 07:05:41 +00:00
3536 lines
171 KiB
Rust
3536 lines
171 KiB
Rust
// Rust test file autogenerated with cargo build (build/spectests.rs).
|
|
// Please do NOT modify it by hand, as it will be reset on next build.
|
|
// Test based on spectests/f32_bitwise.wast
|
|
#![allow(
|
|
warnings,
|
|
dead_code
|
|
)]
|
|
use wabt::wat2wasm;
|
|
use std::{f32, f64};
|
|
|
|
use wasmer_runtime::types::Value;
|
|
use wasmer_runtime::{Instance, module::Module};
|
|
use wasmer_clif_backend::CraneliftCompiler;
|
|
|
|
use crate::spectests::_common::{
|
|
spectest_importobject,
|
|
NaNCheck,
|
|
};
|
|
|
|
|
|
// Line 4
|
|
fn create_module_1() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(type (;0;) (func (param f32) (result f32)))
|
|
(type (;1;) (func (param f32 f32) (result f32)))
|
|
(func (;0;) (type 0) (param f32) (result f32)
|
|
get_local 0
|
|
f32.abs)
|
|
(func (;1;) (type 0) (param f32) (result f32)
|
|
get_local 0
|
|
f32.neg)
|
|
(func (;2;) (type 1) (param f32 f32) (result f32)
|
|
get_local 0
|
|
get_local 1
|
|
f32.copysign)
|
|
(export \"abs\" (func 0))
|
|
(export \"neg\" (func 1))
|
|
(export \"copysign\" (func 2)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_1(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 10
|
|
fn c1_l10_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c1_l10_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 11
|
|
fn c2_l11_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c2_l11_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 12
|
|
fn c3_l12_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c3_l12_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 13
|
|
fn c4_l13_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c4_l13_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 14
|
|
fn c5_l14_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c5_l14_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 15
|
|
fn c6_l15_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c6_l15_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 16
|
|
fn c7_l16_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c7_l16_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 17
|
|
fn c8_l17_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c8_l17_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 18
|
|
fn c9_l18_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c9_l18_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 19
|
|
fn c10_l19_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c10_l19_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 20
|
|
fn c11_l20_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c11_l20_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 21
|
|
fn c12_l21_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c12_l21_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 22
|
|
fn c13_l22_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c13_l22_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 23
|
|
fn c14_l23_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c14_l23_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 24
|
|
fn c15_l24_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c15_l24_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 25
|
|
fn c16_l25_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c16_l25_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 26
|
|
fn c17_l26_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c17_l26_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 27
|
|
fn c18_l27_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c18_l27_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 28
|
|
fn c19_l28_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c19_l28_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 29
|
|
fn c20_l29_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c20_l29_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 30
|
|
fn c21_l30_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c21_l30_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 31
|
|
fn c22_l31_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c22_l31_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 32
|
|
fn c23_l32_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c23_l32_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 33
|
|
fn c24_l33_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c24_l33_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 34
|
|
fn c25_l34_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c25_l34_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 35
|
|
fn c26_l35_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c26_l35_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 36
|
|
fn c27_l36_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c27_l36_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 37
|
|
fn c28_l37_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c28_l37_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 38
|
|
fn c29_l38_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c29_l38_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 39
|
|
fn c30_l39_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c30_l39_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 40
|
|
fn c31_l40_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c31_l40_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 41
|
|
fn c32_l41_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c32_l41_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 42
|
|
fn c33_l42_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c33_l42_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 43
|
|
fn c34_l43_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c34_l43_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 44
|
|
fn c35_l44_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c35_l44_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 45
|
|
fn c36_l45_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c36_l45_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 46
|
|
fn c37_l46_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c37_l46_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 47
|
|
fn c38_l47_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c38_l47_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 48
|
|
fn c39_l48_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c39_l48_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 49
|
|
fn c40_l49_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c40_l49_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 50
|
|
fn c41_l50_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c41_l50_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 51
|
|
fn c42_l51_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c42_l51_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 52
|
|
fn c43_l52_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c43_l52_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 53
|
|
fn c44_l53_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c44_l53_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 54
|
|
fn c45_l54_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c45_l54_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 55
|
|
fn c46_l55_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c46_l55_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 56
|
|
fn c47_l56_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c47_l56_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 57
|
|
fn c48_l57_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c48_l57_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 58
|
|
fn c49_l58_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c49_l58_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 59
|
|
fn c50_l59_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c50_l59_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 60
|
|
fn c51_l60_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c51_l60_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 61
|
|
fn c52_l61_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c52_l61_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 62
|
|
fn c53_l62_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c53_l62_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 63
|
|
fn c54_l63_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c54_l63_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 64
|
|
fn c55_l64_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c55_l64_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 65
|
|
fn c56_l65_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c56_l65_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 66
|
|
fn c57_l66_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c57_l66_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 67
|
|
fn c58_l67_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c58_l67_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 68
|
|
fn c59_l68_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c59_l68_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 69
|
|
fn c60_l69_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c60_l69_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 70
|
|
fn c61_l70_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c61_l70_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 71
|
|
fn c62_l71_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c62_l71_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 72
|
|
fn c63_l72_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c63_l72_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 73
|
|
fn c64_l73_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c64_l73_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 74
|
|
fn c65_l74_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c65_l74_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 75
|
|
fn c66_l75_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c66_l75_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 76
|
|
fn c67_l76_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c67_l76_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 77
|
|
fn c68_l77_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c68_l77_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 78
|
|
fn c69_l78_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c69_l78_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 79
|
|
fn c70_l79_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c70_l79_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 80
|
|
fn c71_l80_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c71_l80_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 81
|
|
fn c72_l81_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c72_l81_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 82
|
|
fn c73_l82_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c73_l82_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 83
|
|
fn c74_l83_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c74_l83_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 84
|
|
fn c75_l84_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c75_l84_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 85
|
|
fn c76_l85_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c76_l85_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 86
|
|
fn c77_l86_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c77_l86_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 87
|
|
fn c78_l87_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c78_l87_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 88
|
|
fn c79_l88_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c79_l88_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 89
|
|
fn c80_l89_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c80_l89_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 90
|
|
fn c81_l90_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c81_l90_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 91
|
|
fn c82_l91_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c82_l91_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 92
|
|
fn c83_l92_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c83_l92_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 93
|
|
fn c84_l93_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c84_l93_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 94
|
|
fn c85_l94_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c85_l94_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 95
|
|
fn c86_l95_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c86_l95_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 96
|
|
fn c87_l96_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c87_l96_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 97
|
|
fn c88_l97_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c88_l97_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 98
|
|
fn c89_l98_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c89_l98_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 99
|
|
fn c90_l99_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c90_l99_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 100
|
|
fn c91_l100_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c91_l100_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 101
|
|
fn c92_l101_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c92_l101_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 102
|
|
fn c93_l102_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c93_l102_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 103
|
|
fn c94_l103_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c94_l103_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 104
|
|
fn c95_l104_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c95_l104_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 105
|
|
fn c96_l105_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c96_l105_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 106
|
|
fn c97_l106_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c97_l106_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 107
|
|
fn c98_l107_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c98_l107_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 108
|
|
fn c99_l108_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c99_l108_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 109
|
|
fn c100_l109_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c100_l109_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 110
|
|
fn c101_l110_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c101_l110_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 111
|
|
fn c102_l111_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c102_l111_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 112
|
|
fn c103_l112_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c103_l112_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 113
|
|
fn c104_l113_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c104_l113_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 114
|
|
fn c105_l114_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c105_l114_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 115
|
|
fn c106_l115_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c106_l115_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 116
|
|
fn c107_l116_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c107_l116_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 117
|
|
fn c108_l117_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c108_l117_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 118
|
|
fn c109_l118_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c109_l118_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 119
|
|
fn c110_l119_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c110_l119_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 120
|
|
fn c111_l120_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c111_l120_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 121
|
|
fn c112_l121_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c112_l121_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 122
|
|
fn c113_l122_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c113_l122_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 123
|
|
fn c114_l123_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c114_l123_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 124
|
|
fn c115_l124_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c115_l124_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 125
|
|
fn c116_l125_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c116_l125_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 126
|
|
fn c117_l126_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c117_l126_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 127
|
|
fn c118_l127_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c118_l127_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 128
|
|
fn c119_l128_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c119_l128_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 129
|
|
fn c120_l129_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c120_l129_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 130
|
|
fn c121_l130_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c121_l130_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 131
|
|
fn c122_l131_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c122_l131_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 132
|
|
fn c123_l132_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c123_l132_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 133
|
|
fn c124_l133_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c124_l133_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 134
|
|
fn c125_l134_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c125_l134_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 135
|
|
fn c126_l135_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c126_l135_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 136
|
|
fn c127_l136_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c127_l136_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 137
|
|
fn c128_l137_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c128_l137_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 138
|
|
fn c129_l138_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c129_l138_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 139
|
|
fn c130_l139_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c130_l139_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 140
|
|
fn c131_l140_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c131_l140_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 141
|
|
fn c132_l141_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c132_l141_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 142
|
|
fn c133_l142_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c133_l142_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 143
|
|
fn c134_l143_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c134_l143_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 144
|
|
fn c135_l144_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c135_l144_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 145
|
|
fn c136_l145_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c136_l145_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 146
|
|
fn c137_l146_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c137_l146_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 147
|
|
fn c138_l147_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c138_l147_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 148
|
|
fn c139_l148_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c139_l148_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 149
|
|
fn c140_l149_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c140_l149_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 150
|
|
fn c141_l150_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c141_l150_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 151
|
|
fn c142_l151_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c142_l151_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 152
|
|
fn c143_l152_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c143_l152_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 153
|
|
fn c144_l153_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c144_l153_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((0.5f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 154
|
|
fn c145_l154_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c145_l154_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 155
|
|
fn c146_l155_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c146_l155_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 156
|
|
fn c147_l156_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c147_l156_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 157
|
|
fn c148_l157_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c148_l157_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 158
|
|
fn c149_l158_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c149_l158_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 159
|
|
fn c150_l159_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c150_l159_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 160
|
|
fn c151_l160_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c151_l160_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 161
|
|
fn c152_l161_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c152_l161_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 162
|
|
fn c153_l162_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c153_l162_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 163
|
|
fn c154_l163_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c154_l163_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 164
|
|
fn c155_l164_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c155_l164_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 165
|
|
fn c156_l165_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c156_l165_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 166
|
|
fn c157_l166_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c157_l166_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 167
|
|
fn c158_l167_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c158_l167_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 168
|
|
fn c159_l168_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c159_l168_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 169
|
|
fn c160_l169_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c160_l169_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 170
|
|
fn c161_l170_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c161_l170_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 171
|
|
fn c162_l171_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c162_l171_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 172
|
|
fn c163_l172_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c163_l172_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 173
|
|
fn c164_l173_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c164_l173_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 174
|
|
fn c165_l174_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c165_l174_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 175
|
|
fn c166_l175_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c166_l175_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 176
|
|
fn c167_l176_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c167_l176_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 177
|
|
fn c168_l177_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c168_l177_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 178
|
|
fn c169_l178_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c169_l178_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 179
|
|
fn c170_l179_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c170_l179_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 180
|
|
fn c171_l180_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c171_l180_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 181
|
|
fn c172_l181_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c172_l181_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 182
|
|
fn c173_l182_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c173_l182_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 183
|
|
fn c174_l183_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c174_l183_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 184
|
|
fn c175_l184_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c175_l184_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 185
|
|
fn c176_l185_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c176_l185_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 186
|
|
fn c177_l186_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c177_l186_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 187
|
|
fn c178_l187_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c178_l187_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 188
|
|
fn c179_l188_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c179_l188_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 189
|
|
fn c180_l189_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c180_l189_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((1.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 190
|
|
fn c181_l190_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c181_l190_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 191
|
|
fn c182_l191_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c182_l191_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 192
|
|
fn c183_l192_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c183_l192_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 193
|
|
fn c184_l193_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c184_l193_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 194
|
|
fn c185_l194_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c185_l194_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 195
|
|
fn c186_l195_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c186_l195_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 196
|
|
fn c187_l196_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c187_l196_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 197
|
|
fn c188_l197_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c188_l197_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 198
|
|
fn c189_l198_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c189_l198_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 199
|
|
fn c190_l199_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c190_l199_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 200
|
|
fn c191_l200_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c191_l200_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 201
|
|
fn c192_l201_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c192_l201_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 202
|
|
fn c193_l202_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c193_l202_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 203
|
|
fn c194_l203_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c194_l203_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 204
|
|
fn c195_l204_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c195_l204_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 205
|
|
fn c196_l205_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c196_l205_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 206
|
|
fn c197_l206_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c197_l206_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 207
|
|
fn c198_l207_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c198_l207_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 208
|
|
fn c199_l208_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c199_l208_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 209
|
|
fn c200_l209_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c200_l209_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 210
|
|
fn c201_l210_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c201_l210_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 211
|
|
fn c202_l211_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c202_l211_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 212
|
|
fn c203_l212_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c203_l212_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 213
|
|
fn c204_l213_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c204_l213_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 214
|
|
fn c205_l214_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c205_l214_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 215
|
|
fn c206_l215_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c206_l215_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 216
|
|
fn c207_l216_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c207_l216_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 217
|
|
fn c208_l217_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c208_l217_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 218
|
|
fn c209_l218_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c209_l218_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 219
|
|
fn c210_l219_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c210_l219_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 220
|
|
fn c211_l220_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c211_l220_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 221
|
|
fn c212_l221_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c212_l221_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 222
|
|
fn c213_l222_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c213_l222_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 223
|
|
fn c214_l223_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c214_l223_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 224
|
|
fn c215_l224_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c215_l224_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 225
|
|
fn c216_l225_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c216_l225_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((6.2831855f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 226
|
|
fn c217_l226_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c217_l226_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 227
|
|
fn c218_l227_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c218_l227_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 228
|
|
fn c219_l228_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c219_l228_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 229
|
|
fn c220_l229_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c220_l229_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 230
|
|
fn c221_l230_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c221_l230_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 231
|
|
fn c222_l231_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c222_l231_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 232
|
|
fn c223_l232_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c223_l232_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 233
|
|
fn c224_l233_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c224_l233_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 234
|
|
fn c225_l234_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c225_l234_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 235
|
|
fn c226_l235_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c226_l235_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 236
|
|
fn c227_l236_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c227_l236_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 237
|
|
fn c228_l237_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c228_l237_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 238
|
|
fn c229_l238_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c229_l238_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 239
|
|
fn c230_l239_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c230_l239_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 240
|
|
fn c231_l240_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c231_l240_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 241
|
|
fn c232_l241_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c232_l241_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 242
|
|
fn c233_l242_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c233_l242_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 243
|
|
fn c234_l243_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c234_l243_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 244
|
|
fn c235_l244_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c235_l244_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 245
|
|
fn c236_l245_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c236_l245_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 246
|
|
fn c237_l246_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c237_l246_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 247
|
|
fn c238_l247_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c238_l247_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 248
|
|
fn c239_l248_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c239_l248_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 249
|
|
fn c240_l249_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c240_l249_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 250
|
|
fn c241_l250_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c241_l250_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 251
|
|
fn c242_l251_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c242_l251_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 252
|
|
fn c243_l252_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c243_l252_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 253
|
|
fn c244_l253_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c244_l253_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 254
|
|
fn c245_l254_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c245_l254_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 255
|
|
fn c246_l255_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c246_l255_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 256
|
|
fn c247_l256_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c247_l256_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 257
|
|
fn c248_l257_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c248_l257_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 258
|
|
fn c249_l258_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c249_l258_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 259
|
|
fn c250_l259_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c250_l259_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 260
|
|
fn c251_l260_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c251_l260_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 261
|
|
fn c252_l261_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c252_l261_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 262
|
|
fn c253_l262_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c253_l262_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 263
|
|
fn c254_l263_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c254_l263_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 264
|
|
fn c255_l264_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c255_l264_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 265
|
|
fn c256_l265_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c256_l265_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 266
|
|
fn c257_l266_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c257_l266_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 267
|
|
fn c258_l267_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c258_l267_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 268
|
|
fn c259_l268_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c259_l268_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 269
|
|
fn c260_l269_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c260_l269_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 270
|
|
fn c261_l270_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c261_l270_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 271
|
|
fn c262_l271_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c262_l271_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 272
|
|
fn c263_l272_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c263_l272_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 273
|
|
fn c264_l273_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c264_l273_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 274
|
|
fn c265_l274_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c265_l274_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 275
|
|
fn c266_l275_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c266_l275_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 276
|
|
fn c267_l276_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c267_l276_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 277
|
|
fn c268_l277_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c268_l277_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 278
|
|
fn c269_l278_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c269_l278_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 279
|
|
fn c270_l279_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c270_l279_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 280
|
|
fn c271_l280_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c271_l280_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 281
|
|
fn c272_l281_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c272_l281_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 282
|
|
fn c273_l282_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c273_l282_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 283
|
|
fn c274_l283_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c274_l283_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 284
|
|
fn c275_l284_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c275_l284_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 285
|
|
fn c276_l285_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c276_l285_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 286
|
|
fn c277_l286_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c277_l286_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 287
|
|
fn c278_l287_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c278_l287_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 288
|
|
fn c279_l288_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c279_l288_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 289
|
|
fn c280_l289_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c280_l289_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 290
|
|
fn c281_l290_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c281_l290_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 291
|
|
fn c282_l291_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c282_l291_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 292
|
|
fn c283_l292_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c283_l292_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 293
|
|
fn c284_l293_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c284_l293_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 294
|
|
fn c285_l294_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c285_l294_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 295
|
|
fn c286_l295_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c286_l295_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::NEG_INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 296
|
|
fn c287_l296_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c287_l296_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 297
|
|
fn c288_l297_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c288_l297_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::INFINITY.to_bits()), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 298
|
|
fn c289_l298_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c289_l298_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.0f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 299
|
|
fn c290_l299_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c290_l299_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.0f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 300
|
|
fn c291_l300_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c291_l300_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.0f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 301
|
|
fn c292_l301_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c292_l301_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.0f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 302
|
|
fn c293_l302_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c293_l302_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 303
|
|
fn c294_l303_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c294_l303_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 304
|
|
fn c295_l304_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c295_l304_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 305
|
|
fn c296_l305_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c296_l305_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 306
|
|
fn c297_l306_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c297_l306_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 307
|
|
fn c298_l307_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c298_l307_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 308
|
|
fn c299_l308_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c299_l308_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 309
|
|
fn c300_l309_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c300_l309_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 310
|
|
fn c301_l310_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c301_l310_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-0.5f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 311
|
|
fn c302_l311_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c302_l311_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((0.5f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 312
|
|
fn c303_l312_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c303_l312_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-0.5f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 313
|
|
fn c304_l313_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c304_l313_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((0.5f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 314
|
|
fn c305_l314_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c305_l314_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-1.0f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 315
|
|
fn c306_l315_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c306_l315_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((1.0f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 316
|
|
fn c307_l316_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c307_l316_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-1.0f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 317
|
|
fn c308_l317_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c308_l317_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((1.0f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 318
|
|
fn c309_l318_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c309_l318_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-6.2831855f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 319
|
|
fn c310_l319_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c310_l319_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((6.2831855f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 320
|
|
fn c311_l320_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c311_l320_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-6.2831855f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 321
|
|
fn c312_l321_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c312_l321_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((6.2831855f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 322
|
|
fn c313_l322_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c313_l322_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 323
|
|
fn c314_l323_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c314_l323_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 324
|
|
fn c315_l324_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c315_l324_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 325
|
|
fn c316_l325_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c316_l325_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 326
|
|
fn c317_l326_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c317_l326_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 327
|
|
fn c318_l327_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c318_l327_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::INFINITY.to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 328
|
|
fn c319_l328_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c319_l328_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 329
|
|
fn c320_l329_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c320_l329_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::INFINITY.to_bits())]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 330
|
|
fn c321_l330_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c321_l330_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 331
|
|
fn c322_l331_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c322_l331_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(4290772992) as u32), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 332
|
|
fn c323_l332_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c323_l332_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 333
|
|
fn c324_l333_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c324_l333_action_invoke");
|
|
let result = instance.call("copysign", &[Value::F32(f32::from_bits(2143289344) as u32), Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 334
|
|
fn c325_l334_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c325_l334_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 335
|
|
fn c326_l335_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c326_l335_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 336
|
|
fn c327_l336_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c327_l336_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 337
|
|
fn c328_l337_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c328_l337_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 338
|
|
fn c329_l338_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c329_l338_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 339
|
|
fn c330_l339_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c330_l339_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 340
|
|
fn c331_l340_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c331_l340_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 341
|
|
fn c332_l341_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c332_l341_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 342
|
|
fn c333_l342_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c333_l342_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 343
|
|
fn c334_l343_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c334_l343_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 344
|
|
fn c335_l344_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c335_l344_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 345
|
|
fn c336_l345_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c336_l345_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 346
|
|
fn c337_l346_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c337_l346_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 347
|
|
fn c338_l347_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c338_l347_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 348
|
|
fn c339_l348_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c339_l348_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 349
|
|
fn c340_l349_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c340_l349_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 350
|
|
fn c341_l350_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c341_l350_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 351
|
|
fn c342_l351_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c342_l351_action_invoke");
|
|
let result = instance.call("abs", &[Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 352
|
|
fn c343_l352_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c343_l352_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((-0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 353
|
|
fn c344_l353_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c344_l353_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((0.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 354
|
|
fn c345_l354_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c345_l354_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 355
|
|
fn c346_l355_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c346_l355_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((0.000000000000000000000000000000000000000000001f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000000000001f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 356
|
|
fn c347_l356_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c347_l356_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 357
|
|
fn c348_l357_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c348_l357_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((0.000000000000000000000000000000000000011754944f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.000000000000000000000000000000000000011754944f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 358
|
|
fn c349_l358_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c349_l358_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((-0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 359
|
|
fn c350_l359_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c350_l359_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((0.5f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-0.5f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 360
|
|
fn c351_l360_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c351_l360_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((-1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 361
|
|
fn c352_l361_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c352_l361_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((1.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-1.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 362
|
|
fn c353_l362_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c353_l362_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((-6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 363
|
|
fn c354_l363_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c354_l363_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((6.2831855f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-6.2831855f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 364
|
|
fn c355_l364_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c355_l364_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((-340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 365
|
|
fn c356_l365_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c356_l365_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32((340282350000000000000000000000000000000.0f32).to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32((-340282350000000000000000000000000000000.0f32).to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 366
|
|
fn c357_l366_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c357_l366_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32(f32::NEG_INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 367
|
|
fn c358_l367_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c358_l367_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32(f32::INFINITY.to_bits())]);
|
|
assert_eq!(result, Ok(Some(Value::F32(f32::NEG_INFINITY.to_bits()))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 368
|
|
fn c359_l368_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c359_l368_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32(f32::from_bits(4290772992) as u32)]);
|
|
let expected = f32::from_bits(2143289344);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 369
|
|
fn c360_l369_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c360_l369_action_invoke");
|
|
let result = instance.call("neg", &[Value::F32(f32::from_bits(2143289344) as u32)]);
|
|
let expected = f32::from_bits(4290772992);
|
|
if let Value::F32(result) = result.clone().unwrap().unwrap() {
|
|
assert!((result as f32).is_nan());
|
|
assert_eq!((result as f32).is_sign_positive(), (expected as f32).is_sign_positive());
|
|
} else {
|
|
panic!("Unexpected result type {:?}", result);
|
|
}
|
|
result.map(|_| ())
|
|
}
|
|
|
|
#[test]
|
|
fn test_module_1() {
|
|
let mut instance = create_module_1();
|
|
// We group the calls together
|
|
start_module_1(&mut instance);
|
|
c1_l10_action_invoke(&mut instance);
|
|
c2_l11_action_invoke(&mut instance);
|
|
c3_l12_action_invoke(&mut instance);
|
|
c4_l13_action_invoke(&mut instance);
|
|
c5_l14_action_invoke(&mut instance);
|
|
c6_l15_action_invoke(&mut instance);
|
|
c7_l16_action_invoke(&mut instance);
|
|
c8_l17_action_invoke(&mut instance);
|
|
c9_l18_action_invoke(&mut instance);
|
|
c10_l19_action_invoke(&mut instance);
|
|
c11_l20_action_invoke(&mut instance);
|
|
c12_l21_action_invoke(&mut instance);
|
|
c13_l22_action_invoke(&mut instance);
|
|
c14_l23_action_invoke(&mut instance);
|
|
c15_l24_action_invoke(&mut instance);
|
|
c16_l25_action_invoke(&mut instance);
|
|
c17_l26_action_invoke(&mut instance);
|
|
c18_l27_action_invoke(&mut instance);
|
|
c19_l28_action_invoke(&mut instance);
|
|
c20_l29_action_invoke(&mut instance);
|
|
c21_l30_action_invoke(&mut instance);
|
|
c22_l31_action_invoke(&mut instance);
|
|
c23_l32_action_invoke(&mut instance);
|
|
c24_l33_action_invoke(&mut instance);
|
|
c25_l34_action_invoke(&mut instance);
|
|
c26_l35_action_invoke(&mut instance);
|
|
c27_l36_action_invoke(&mut instance);
|
|
c28_l37_action_invoke(&mut instance);
|
|
c29_l38_action_invoke(&mut instance);
|
|
c30_l39_action_invoke(&mut instance);
|
|
c31_l40_action_invoke(&mut instance);
|
|
c32_l41_action_invoke(&mut instance);
|
|
c33_l42_action_invoke(&mut instance);
|
|
c34_l43_action_invoke(&mut instance);
|
|
c35_l44_action_invoke(&mut instance);
|
|
c36_l45_action_invoke(&mut instance);
|
|
c37_l46_action_invoke(&mut instance);
|
|
c38_l47_action_invoke(&mut instance);
|
|
c39_l48_action_invoke(&mut instance);
|
|
c40_l49_action_invoke(&mut instance);
|
|
c41_l50_action_invoke(&mut instance);
|
|
c42_l51_action_invoke(&mut instance);
|
|
c43_l52_action_invoke(&mut instance);
|
|
c44_l53_action_invoke(&mut instance);
|
|
c45_l54_action_invoke(&mut instance);
|
|
c46_l55_action_invoke(&mut instance);
|
|
c47_l56_action_invoke(&mut instance);
|
|
c48_l57_action_invoke(&mut instance);
|
|
c49_l58_action_invoke(&mut instance);
|
|
c50_l59_action_invoke(&mut instance);
|
|
c51_l60_action_invoke(&mut instance);
|
|
c52_l61_action_invoke(&mut instance);
|
|
c53_l62_action_invoke(&mut instance);
|
|
c54_l63_action_invoke(&mut instance);
|
|
c55_l64_action_invoke(&mut instance);
|
|
c56_l65_action_invoke(&mut instance);
|
|
c57_l66_action_invoke(&mut instance);
|
|
c58_l67_action_invoke(&mut instance);
|
|
c59_l68_action_invoke(&mut instance);
|
|
c60_l69_action_invoke(&mut instance);
|
|
c61_l70_action_invoke(&mut instance);
|
|
c62_l71_action_invoke(&mut instance);
|
|
c63_l72_action_invoke(&mut instance);
|
|
c64_l73_action_invoke(&mut instance);
|
|
c65_l74_action_invoke(&mut instance);
|
|
c66_l75_action_invoke(&mut instance);
|
|
c67_l76_action_invoke(&mut instance);
|
|
c68_l77_action_invoke(&mut instance);
|
|
c69_l78_action_invoke(&mut instance);
|
|
c70_l79_action_invoke(&mut instance);
|
|
c71_l80_action_invoke(&mut instance);
|
|
c72_l81_action_invoke(&mut instance);
|
|
c73_l82_action_invoke(&mut instance);
|
|
c74_l83_action_invoke(&mut instance);
|
|
c75_l84_action_invoke(&mut instance);
|
|
c76_l85_action_invoke(&mut instance);
|
|
c77_l86_action_invoke(&mut instance);
|
|
c78_l87_action_invoke(&mut instance);
|
|
c79_l88_action_invoke(&mut instance);
|
|
c80_l89_action_invoke(&mut instance);
|
|
c81_l90_action_invoke(&mut instance);
|
|
c82_l91_action_invoke(&mut instance);
|
|
c83_l92_action_invoke(&mut instance);
|
|
c84_l93_action_invoke(&mut instance);
|
|
c85_l94_action_invoke(&mut instance);
|
|
c86_l95_action_invoke(&mut instance);
|
|
c87_l96_action_invoke(&mut instance);
|
|
c88_l97_action_invoke(&mut instance);
|
|
c89_l98_action_invoke(&mut instance);
|
|
c90_l99_action_invoke(&mut instance);
|
|
c91_l100_action_invoke(&mut instance);
|
|
c92_l101_action_invoke(&mut instance);
|
|
c93_l102_action_invoke(&mut instance);
|
|
c94_l103_action_invoke(&mut instance);
|
|
c95_l104_action_invoke(&mut instance);
|
|
c96_l105_action_invoke(&mut instance);
|
|
c97_l106_action_invoke(&mut instance);
|
|
c98_l107_action_invoke(&mut instance);
|
|
c99_l108_action_invoke(&mut instance);
|
|
c100_l109_action_invoke(&mut instance);
|
|
c101_l110_action_invoke(&mut instance);
|
|
c102_l111_action_invoke(&mut instance);
|
|
c103_l112_action_invoke(&mut instance);
|
|
c104_l113_action_invoke(&mut instance);
|
|
c105_l114_action_invoke(&mut instance);
|
|
c106_l115_action_invoke(&mut instance);
|
|
c107_l116_action_invoke(&mut instance);
|
|
c108_l117_action_invoke(&mut instance);
|
|
c109_l118_action_invoke(&mut instance);
|
|
c110_l119_action_invoke(&mut instance);
|
|
c111_l120_action_invoke(&mut instance);
|
|
c112_l121_action_invoke(&mut instance);
|
|
c113_l122_action_invoke(&mut instance);
|
|
c114_l123_action_invoke(&mut instance);
|
|
c115_l124_action_invoke(&mut instance);
|
|
c116_l125_action_invoke(&mut instance);
|
|
c117_l126_action_invoke(&mut instance);
|
|
c118_l127_action_invoke(&mut instance);
|
|
c119_l128_action_invoke(&mut instance);
|
|
c120_l129_action_invoke(&mut instance);
|
|
c121_l130_action_invoke(&mut instance);
|
|
c122_l131_action_invoke(&mut instance);
|
|
c123_l132_action_invoke(&mut instance);
|
|
c124_l133_action_invoke(&mut instance);
|
|
c125_l134_action_invoke(&mut instance);
|
|
c126_l135_action_invoke(&mut instance);
|
|
c127_l136_action_invoke(&mut instance);
|
|
c128_l137_action_invoke(&mut instance);
|
|
c129_l138_action_invoke(&mut instance);
|
|
c130_l139_action_invoke(&mut instance);
|
|
c131_l140_action_invoke(&mut instance);
|
|
c132_l141_action_invoke(&mut instance);
|
|
c133_l142_action_invoke(&mut instance);
|
|
c134_l143_action_invoke(&mut instance);
|
|
c135_l144_action_invoke(&mut instance);
|
|
c136_l145_action_invoke(&mut instance);
|
|
c137_l146_action_invoke(&mut instance);
|
|
c138_l147_action_invoke(&mut instance);
|
|
c139_l148_action_invoke(&mut instance);
|
|
c140_l149_action_invoke(&mut instance);
|
|
c141_l150_action_invoke(&mut instance);
|
|
c142_l151_action_invoke(&mut instance);
|
|
c143_l152_action_invoke(&mut instance);
|
|
c144_l153_action_invoke(&mut instance);
|
|
c145_l154_action_invoke(&mut instance);
|
|
c146_l155_action_invoke(&mut instance);
|
|
c147_l156_action_invoke(&mut instance);
|
|
c148_l157_action_invoke(&mut instance);
|
|
c149_l158_action_invoke(&mut instance);
|
|
c150_l159_action_invoke(&mut instance);
|
|
c151_l160_action_invoke(&mut instance);
|
|
c152_l161_action_invoke(&mut instance);
|
|
c153_l162_action_invoke(&mut instance);
|
|
c154_l163_action_invoke(&mut instance);
|
|
c155_l164_action_invoke(&mut instance);
|
|
c156_l165_action_invoke(&mut instance);
|
|
c157_l166_action_invoke(&mut instance);
|
|
c158_l167_action_invoke(&mut instance);
|
|
c159_l168_action_invoke(&mut instance);
|
|
c160_l169_action_invoke(&mut instance);
|
|
c161_l170_action_invoke(&mut instance);
|
|
c162_l171_action_invoke(&mut instance);
|
|
c163_l172_action_invoke(&mut instance);
|
|
c164_l173_action_invoke(&mut instance);
|
|
c165_l174_action_invoke(&mut instance);
|
|
c166_l175_action_invoke(&mut instance);
|
|
c167_l176_action_invoke(&mut instance);
|
|
c168_l177_action_invoke(&mut instance);
|
|
c169_l178_action_invoke(&mut instance);
|
|
c170_l179_action_invoke(&mut instance);
|
|
c171_l180_action_invoke(&mut instance);
|
|
c172_l181_action_invoke(&mut instance);
|
|
c173_l182_action_invoke(&mut instance);
|
|
c174_l183_action_invoke(&mut instance);
|
|
c175_l184_action_invoke(&mut instance);
|
|
c176_l185_action_invoke(&mut instance);
|
|
c177_l186_action_invoke(&mut instance);
|
|
c178_l187_action_invoke(&mut instance);
|
|
c179_l188_action_invoke(&mut instance);
|
|
c180_l189_action_invoke(&mut instance);
|
|
c181_l190_action_invoke(&mut instance);
|
|
c182_l191_action_invoke(&mut instance);
|
|
c183_l192_action_invoke(&mut instance);
|
|
c184_l193_action_invoke(&mut instance);
|
|
c185_l194_action_invoke(&mut instance);
|
|
c186_l195_action_invoke(&mut instance);
|
|
c187_l196_action_invoke(&mut instance);
|
|
c188_l197_action_invoke(&mut instance);
|
|
c189_l198_action_invoke(&mut instance);
|
|
c190_l199_action_invoke(&mut instance);
|
|
c191_l200_action_invoke(&mut instance);
|
|
c192_l201_action_invoke(&mut instance);
|
|
c193_l202_action_invoke(&mut instance);
|
|
c194_l203_action_invoke(&mut instance);
|
|
c195_l204_action_invoke(&mut instance);
|
|
c196_l205_action_invoke(&mut instance);
|
|
c197_l206_action_invoke(&mut instance);
|
|
c198_l207_action_invoke(&mut instance);
|
|
c199_l208_action_invoke(&mut instance);
|
|
c200_l209_action_invoke(&mut instance);
|
|
c201_l210_action_invoke(&mut instance);
|
|
c202_l211_action_invoke(&mut instance);
|
|
c203_l212_action_invoke(&mut instance);
|
|
c204_l213_action_invoke(&mut instance);
|
|
c205_l214_action_invoke(&mut instance);
|
|
c206_l215_action_invoke(&mut instance);
|
|
c207_l216_action_invoke(&mut instance);
|
|
c208_l217_action_invoke(&mut instance);
|
|
c209_l218_action_invoke(&mut instance);
|
|
c210_l219_action_invoke(&mut instance);
|
|
c211_l220_action_invoke(&mut instance);
|
|
c212_l221_action_invoke(&mut instance);
|
|
c213_l222_action_invoke(&mut instance);
|
|
c214_l223_action_invoke(&mut instance);
|
|
c215_l224_action_invoke(&mut instance);
|
|
c216_l225_action_invoke(&mut instance);
|
|
c217_l226_action_invoke(&mut instance);
|
|
c218_l227_action_invoke(&mut instance);
|
|
c219_l228_action_invoke(&mut instance);
|
|
c220_l229_action_invoke(&mut instance);
|
|
c221_l230_action_invoke(&mut instance);
|
|
c222_l231_action_invoke(&mut instance);
|
|
c223_l232_action_invoke(&mut instance);
|
|
c224_l233_action_invoke(&mut instance);
|
|
c225_l234_action_invoke(&mut instance);
|
|
c226_l235_action_invoke(&mut instance);
|
|
c227_l236_action_invoke(&mut instance);
|
|
c228_l237_action_invoke(&mut instance);
|
|
c229_l238_action_invoke(&mut instance);
|
|
c230_l239_action_invoke(&mut instance);
|
|
c231_l240_action_invoke(&mut instance);
|
|
c232_l241_action_invoke(&mut instance);
|
|
c233_l242_action_invoke(&mut instance);
|
|
c234_l243_action_invoke(&mut instance);
|
|
c235_l244_action_invoke(&mut instance);
|
|
c236_l245_action_invoke(&mut instance);
|
|
c237_l246_action_invoke(&mut instance);
|
|
c238_l247_action_invoke(&mut instance);
|
|
c239_l248_action_invoke(&mut instance);
|
|
c240_l249_action_invoke(&mut instance);
|
|
c241_l250_action_invoke(&mut instance);
|
|
c242_l251_action_invoke(&mut instance);
|
|
c243_l252_action_invoke(&mut instance);
|
|
c244_l253_action_invoke(&mut instance);
|
|
c245_l254_action_invoke(&mut instance);
|
|
c246_l255_action_invoke(&mut instance);
|
|
c247_l256_action_invoke(&mut instance);
|
|
c248_l257_action_invoke(&mut instance);
|
|
c249_l258_action_invoke(&mut instance);
|
|
c250_l259_action_invoke(&mut instance);
|
|
c251_l260_action_invoke(&mut instance);
|
|
c252_l261_action_invoke(&mut instance);
|
|
c253_l262_action_invoke(&mut instance);
|
|
c254_l263_action_invoke(&mut instance);
|
|
c255_l264_action_invoke(&mut instance);
|
|
c256_l265_action_invoke(&mut instance);
|
|
c257_l266_action_invoke(&mut instance);
|
|
c258_l267_action_invoke(&mut instance);
|
|
c259_l268_action_invoke(&mut instance);
|
|
c260_l269_action_invoke(&mut instance);
|
|
c261_l270_action_invoke(&mut instance);
|
|
c262_l271_action_invoke(&mut instance);
|
|
c263_l272_action_invoke(&mut instance);
|
|
c264_l273_action_invoke(&mut instance);
|
|
c265_l274_action_invoke(&mut instance);
|
|
c266_l275_action_invoke(&mut instance);
|
|
c267_l276_action_invoke(&mut instance);
|
|
c268_l277_action_invoke(&mut instance);
|
|
c269_l278_action_invoke(&mut instance);
|
|
c270_l279_action_invoke(&mut instance);
|
|
c271_l280_action_invoke(&mut instance);
|
|
c272_l281_action_invoke(&mut instance);
|
|
c273_l282_action_invoke(&mut instance);
|
|
c274_l283_action_invoke(&mut instance);
|
|
c275_l284_action_invoke(&mut instance);
|
|
c276_l285_action_invoke(&mut instance);
|
|
c277_l286_action_invoke(&mut instance);
|
|
c278_l287_action_invoke(&mut instance);
|
|
c279_l288_action_invoke(&mut instance);
|
|
c280_l289_action_invoke(&mut instance);
|
|
c281_l290_action_invoke(&mut instance);
|
|
c282_l291_action_invoke(&mut instance);
|
|
c283_l292_action_invoke(&mut instance);
|
|
c284_l293_action_invoke(&mut instance);
|
|
c285_l294_action_invoke(&mut instance);
|
|
c286_l295_action_invoke(&mut instance);
|
|
c287_l296_action_invoke(&mut instance);
|
|
c288_l297_action_invoke(&mut instance);
|
|
c289_l298_action_invoke(&mut instance);
|
|
c290_l299_action_invoke(&mut instance);
|
|
c291_l300_action_invoke(&mut instance);
|
|
c292_l301_action_invoke(&mut instance);
|
|
c293_l302_action_invoke(&mut instance);
|
|
c294_l303_action_invoke(&mut instance);
|
|
c295_l304_action_invoke(&mut instance);
|
|
c296_l305_action_invoke(&mut instance);
|
|
c297_l306_action_invoke(&mut instance);
|
|
c298_l307_action_invoke(&mut instance);
|
|
c299_l308_action_invoke(&mut instance);
|
|
c300_l309_action_invoke(&mut instance);
|
|
c301_l310_action_invoke(&mut instance);
|
|
c302_l311_action_invoke(&mut instance);
|
|
c303_l312_action_invoke(&mut instance);
|
|
c304_l313_action_invoke(&mut instance);
|
|
c305_l314_action_invoke(&mut instance);
|
|
c306_l315_action_invoke(&mut instance);
|
|
c307_l316_action_invoke(&mut instance);
|
|
c308_l317_action_invoke(&mut instance);
|
|
c309_l318_action_invoke(&mut instance);
|
|
c310_l319_action_invoke(&mut instance);
|
|
c311_l320_action_invoke(&mut instance);
|
|
c312_l321_action_invoke(&mut instance);
|
|
c313_l322_action_invoke(&mut instance);
|
|
c314_l323_action_invoke(&mut instance);
|
|
c315_l324_action_invoke(&mut instance);
|
|
c316_l325_action_invoke(&mut instance);
|
|
c317_l326_action_invoke(&mut instance);
|
|
c318_l327_action_invoke(&mut instance);
|
|
c319_l328_action_invoke(&mut instance);
|
|
c320_l329_action_invoke(&mut instance);
|
|
c321_l330_action_invoke(&mut instance);
|
|
c322_l331_action_invoke(&mut instance);
|
|
c323_l332_action_invoke(&mut instance);
|
|
c324_l333_action_invoke(&mut instance);
|
|
c325_l334_action_invoke(&mut instance);
|
|
c326_l335_action_invoke(&mut instance);
|
|
c327_l336_action_invoke(&mut instance);
|
|
c328_l337_action_invoke(&mut instance);
|
|
c329_l338_action_invoke(&mut instance);
|
|
c330_l339_action_invoke(&mut instance);
|
|
c331_l340_action_invoke(&mut instance);
|
|
c332_l341_action_invoke(&mut instance);
|
|
c333_l342_action_invoke(&mut instance);
|
|
c334_l343_action_invoke(&mut instance);
|
|
c335_l344_action_invoke(&mut instance);
|
|
c336_l345_action_invoke(&mut instance);
|
|
c337_l346_action_invoke(&mut instance);
|
|
c338_l347_action_invoke(&mut instance);
|
|
c339_l348_action_invoke(&mut instance);
|
|
c340_l349_action_invoke(&mut instance);
|
|
c341_l350_action_invoke(&mut instance);
|
|
c342_l351_action_invoke(&mut instance);
|
|
c343_l352_action_invoke(&mut instance);
|
|
c344_l353_action_invoke(&mut instance);
|
|
c345_l354_action_invoke(&mut instance);
|
|
c346_l355_action_invoke(&mut instance);
|
|
c347_l356_action_invoke(&mut instance);
|
|
c348_l357_action_invoke(&mut instance);
|
|
c349_l358_action_invoke(&mut instance);
|
|
c350_l359_action_invoke(&mut instance);
|
|
c351_l360_action_invoke(&mut instance);
|
|
c352_l361_action_invoke(&mut instance);
|
|
c353_l362_action_invoke(&mut instance);
|
|
c354_l363_action_invoke(&mut instance);
|
|
c355_l364_action_invoke(&mut instance);
|
|
c356_l365_action_invoke(&mut instance);
|
|
c357_l366_action_invoke(&mut instance);
|
|
c358_l367_action_invoke(&mut instance);
|
|
c359_l368_action_invoke(&mut instance);
|
|
c360_l369_action_invoke(&mut instance);
|
|
}
|